Welcome to Protogame

Protogame is a cross-platform .NET game engine. It aims to allow developers to prototype games quickly during the early stages of development, and then scale those games into full projects.

Protogame is fully open source and available under an MIT license.

This documentation is organised into several sections, depending on what you need to achieve:

• General Information
• Basic Walkthroughs
• Engine API
• Engine Utilities
• Third-Party APIs

General Information

Frequently Asked Questions

If there is a question not answered here, ask @hachque on Twitter.

How do I get started?

We recommend reading the Creating your first game as this will guide you through the initial download and setup, and lead onto future tutorials which cover rendering, entities and handling input.

What platforms are supported?

Windows, Mac OS X and Linux are all currently supported and tested development platforms. These desktop platforms are also supported targets for running games made with Protogame.

Android and Ouya are currently supported mobile platforms for running games. iOS support is expected in the future.

MonoGame supports other platforms as well, such as PlayStation Mobile and Native Client. We don’t know whether Protogame will work on these platforms, but it’s likely they will work with some changes depending on platform limitations.

For more information, refer to the table below.

• “Supported” indicates that we actively develop and run games on this platform.
• “Changes Needed” means that you would need to make changes to the engine for it to work.
• An empty space means it’s not supported and / or we don’t know how well it will work.

Platform	Games can be developed on this platform	Games can run on this platform
Windows	Supported	Supported
Mac OS X	Supported	Supported
Linux	Supported	Supported
Android		Supported
Ouya		Supported
iOS		Supported
Windows Phone
Windows 8 (Metro)

What platforms can compile assets?

Asset compilation is needed to turn source information (such as PNG and FBX files) into a version of the texture, model or otherwise that is suitable for the game to use at runtime. Since each platform needs assets in different formats, you have to compile your assets for the target platforms.

Support is determined by:

• The type of asset
• The platform you are targetting (for running the game)
• The platform you are compiling the asset on (where you are developing)

The general rule of thumb is, if you are developing on Windows, you can target all platforms. Windows has the strongest support for compiling assets and can target all available platforms that MonoGame supports.

Linux support can compile all types of assets, although shaders require another computer running Windows for remote compilation (effects require DirectX to parse the shader language). Fonts must be under the /usr/share/fonts/truetype folder for them to be picked up, and the font name indicates the TTF filename.

Font compilation is likely to change in the future, with font assets being specified from a source TTF instead of by name.

You will need a Windows machine to compile shaders.

See the Asset Management article for more information on compile assets, cross-compilation and compilation of shaders on non-Windows platforms.

Missing MSVCR100.dll or MSVCP100.dll

Compilation of model assets under Windows requires the Visual C++ runtime.

FBX animations are not importing from Maya correctly

The FBX importer has some restrictions about the structure of the animations that you import. These relate to “optimizations” that Maya and other 3D modelling tools do in their export; unfortunately these optimizations are not compatible with the importer.

The restrictions are as follows:

• All bones in the hierarchy must have a joint offset. Maya is known to optimize hierarchy that doesn’t have a joint offset, and this causes transformations to be applied to the wrong node.
• You must have at least one frame for each bone with a non-default value for translation, rotation and scaling. If you leave the default translation (0, 0, 0), rotation (0, 0, 0), scaling (1, 1, 1) for a given bone, and you export a rig with no animations, relevant nodes for the bone will not be exported and Protogame will not be able to re-apply the animation transformations because the target node does not exist. An easy solution to this issue is to have the base FBX file also contain an animation, so Maya will not remove the nodes required to re-apply the animation.

Note that these restrictions only apply when you are dealing with animations. Non-animated FBX files will import just fine.

Running games under Mono for Windows does not work

Running Protogame-based games under Mono for Windows is not supported. Please use the Microsoft.NET runtime instead.

This means that you should use Visual Studio Express instead of Xamarin Studio if your target is the Windows platform (i.e. on Windows use Xamarin Studio only if the runtime platform is Android or iOS).

‘FastDev directory creation failed’ when deploying to Android

This appears to be a transient error with Xamarin Android. To fix this issue, right-click on the project for your game in Xamarin Studio and select “Options”. In the Options dialog that appears, under Build -> Android Build, uncheck the “Fast Assembly Deployment” option.

Basic Walkthroughs

If you’re just starting out with Protogame, it is highly recommended that you follow the first walkthrough: Creating your first game. This will walk you through creating your first game with absolutely nothing installed or set up.

Creating your first game

Unlike other game engines, Protogame is not installed on your computer; instead it is a library that you download for each project. If you’ve ever used FlashPunk, you’ll be used to this way of working.

Install an IDE

It’s pretty safe to assume that you’ve already done this step, especially if you’ve been developing in C# before.

You will need either Visual Studio, Xamarin Studio or MonoDevelop. You can also use command-line build tools such as msbuild or xbuild if you wish.

Visual Studio Community

If you are developing on Windows, then Visual Studio Community is highly recommended. You can download Visual Studio Community from the Visual Studio website.

Xamarin Studio / MonoDevelop

If you are developing on Mac OS X or Linux, or you want to target mobile platforms through Xamarin, you’ll need to use Xamarin Studio or MonoDevelop.

Xamarin Studio for Windows or Mac OS X can be downloaded from the Xamarin download site.

MonoDevelop for Linux can be downloaded through the package manager for your Linux distribution.

Install Protobuild

Protobuild is a cross-platform project manager for .NET. It makes developing cross-platform games in C# easy, by taking care of all of the platform-specific dependencies you need.

To install Protobuild, go the Protobuild website and install it for the operating system you want to develop on.

Download Protobuild

After you have installed Protobuild, run the Protobuild Manager from your Start Menu (on Windows), Spotlight (on Mac) or KDE/GNOME menu (on Linux).

Create your project

Once you have the Protobuild Manager open, you should see the following start screen:

From here, click on “Create New Project” and select the Empty Project template:

Give your project a name, and click “Create Project”. Leave the project type as “Protobuild”.

This will take a while Protogame is downloaded and all of the dependencies are fetched:

Once this finishes, either Visual Studio, Xamarin Studio or MonoDevelop will be automatically launched to open your project.

Note

In future you should open your project through the Protobuild Manager rather than your IDE. This will ensure that the cross-platform information about your project is saved correctly.

Running the game

Once you have opened the solution file with your IDE, you can build and run the game.

Starting the debugger

Under Visual Studio, you can run the game with the “Debug” button on the toolbar:

Under Xamarin Studio or MonoDevelop, you can run the game with the large “Play” icon:

Verifying everything works

If you have downloaded the blank template, you should now see something similar to the following window when running the game:

Next steps

We recommend continuing onto the next walkthough, Rendering textures.

Rendering textures

Warning

For this walkthrough, we are assuming you are starting from the blank template. If you haven’t downloaded the blank template, please see Creating your first game first.

The blank template starts you off with a very basic structure; just enough to run a game on your development platform.

One of the most essential components of a game is the ability to render graphics to the screen. Although the blank template demonstrates rendering text (using the built in font), it does not cover how to render a texture.

This tutorial will cover both importing a texture into the content directory, and then rendering this texture as part of the world’s “RenderAbove” logic.

For this tutorial, we’ll be using the following image:

Right-click on the image above and save the image to your local computer.

This image is licensed CC0 / Public Domain from OpenGameArt. It was sourced from http://opengameart.org/content/stg-object-image.

Importing a texture

Protogame uses content projects to reference and compile various different types of assets, such as textures, audio, models and shaders.

The blank template will give you a project layout like the following:

In this structure, the MyProject folder is where your code is being stored; for example the MyProjectWorld.cs file is located in here.

We need to add the texture file to the content project, which is stored as the MyProject.Content project.

Warning

Protogame content projects do not work in the same way as XNA content projects. There is no explicit “content project file” with the .contentproj extension, as these types of projects do not work on any platform other Windows / XNA.

To import the texture, it is a simple case of placing the PNG file within the content project folder. It is general convention to organise assets by their type; because are importing a texture, we create a texture folder and then place our PNG file within it.

Once this is complete, you should end up with a structure like the following:

Due to the way content projects work in Protogame, you now need to resynchronise the projects with the Protobuild Manager. On this screen, press the “Re-sync Now” button:

Danger

You must resynchronise cross-platform projects at this point. If you do not, the texture will not be copied to the output folder upon build, and you will not be able to load it.

After running Protobuild, the project should now show the texture within the MyGame project:

Rendering a texture: Summary

Now that we have imported our texture, we need to call the appropriate Protogame APIs to render the texture.

Since we have not yet covered adding entities to the game, we will be adding the render call to the world’s render logic.

To be able to render textures in a game, we need to have four steps completed:

1. Inject the I2DRenderUtilities interface. This provides the API to render the texture.
2. Inject the IAssetManagerProvider interface. From this we can gain access to the asset manager, and from there gain access to our texture asset.
3. Gain a reference to the texture asset within the world’s constructor.
4. Call the RenderTexture method against I2DRenderUtilities within the render loop.

Luckily for us, the blank template already injects both the I2DRenderUtilities and IAssetManagerProvider interfaces, as it needs these interfaces to perform text rendering.

However, we still need to gain a reference to the texture asset and store it for later usage within the render loop.

Referencing an asset

To reference an asset, we gain a reference to the asset manager and call the Get method. To gain access to our texture, add the following call to the world’s constructor:

_playerTexture = _assetManager.Get<TextureAsset>("texture.Player");

You will also need to add a field to the world implementation for storing a reference to the player texture:

private readonly TextureAsset _playerTexture;

Overall, the start of the world implementation should now look similar to this:

namespace MyGame
{
    using System.Collections.Generic;

    using Microsoft.Xna.Framework;

    using Protogame;

    public class MyGameWorld : IWorld
    {
        private readonly I2DRenderUtilities _renderUtilities;

        private readonly IAssetManager _assetManager;

        private readonly FontAsset _defaultFont;

        private readonly TextureAsset _playerTexture;
        
        public MyGameWorld(
            I2DRenderUtilities renderUtilities,
            IAssetManagerProvider assetManagerProvider,
            IEntityFactory entityFactory)
        {
            this.Entities = new List<IEntity>();

            _renderUtilities = renderUtilities;
            _assetManager = assetManagerProvider.GetAssetManager();
            _defaultFont = this._assetManager.Get<FontAsset>("font.Default");

            // You can also save the entity factory in a field and use it, e.g. in the Update
            // loop or anywhere else in your game.
            var entityA = entityFactory.CreateExampleEntity("EntityA");
            entityA.X = 100;
            entityA.Y = 50;
            var entityB = entityFactory.CreateExampleEntity("EntityB");
            entityB.X = 120;
            entityB.Y = 100;

            // Don't forget to add your entities to the world!
            this.Entities.Add(entityA);
            this.Entities.Add(entityB);

            // This pulls in the texture asset via the asset manager.  Note that
            // the folder seperator from "texture/Player" has been translated
            // into a single dot.
            _playerTexture = _assetManager.Get<TextureAsset>("texture.Player");
        }

        // ... more code ...
    }
}

Call the 2D Render Utilities API

Inside the render loop, we now need to call the API to render the texture. Add the following call to the end of the RenderBelow method:

_renderUtilities.RenderTexture(
    renderContext,
    new Vector2(100, 200),
    _playerTexture);

This should result in the RenderBelow method looking similar to the following code:

public void RenderBelow(IGameContext gameContext, IRenderContext renderContext)
{
    gameContext.Graphics.GraphicsDevice.Clear(Color.Purple);

    _renderUtilities.RenderText(
        renderContext,
        new Vector2(10, 10),
        "Hello MyGame!",
        this._defaultFont);

    _renderUtilities.RenderText(
        renderContext,
        new Vector2(10, 30),
        "Running at " + gameContext.FPS + " FPS; " + gameContext.FrameCount + " frames counted so far",
        this._defaultFont);

    _renderUtilities.RenderTexture(
        renderContext,
        new Vector2(100, 200),
        _playerTexture);
}

Viewing the result

If you now build and run the game, you should see the following appear:

Next steps

We recommend continuing onto the next walkthough, Add a player.

Add a player

Danger

This walkthrough is seriously out-of-date. It will be updated in the near future.

Warning

For this walkthrough, we are assuming you are following on from the Rendering textures walkthrough.

The rendering textures tutorial introduced rendering a player texture as part of the world’s render loop. Obviously in a full game we can not be placing rendering and update logic for every object in the world, so we need some way of abstracting these concepts apart.

Entities are the concept that seperates individual instances of “things” in the game world; everything from players to enemies are encapsulated as entities.

Note

For more information about the exact sequence of Update and Render calls on entities, refer to the Updating and rendering documentation.

Defining a new entity

Now we need to define a new player entity. Entities are defined by implementing the IEntity interface. The most simplest entity that we can define (that also does nothing), is:

using System;
using Protogame;

namespace MyGame
{
    public class PlayerEntity : IEntity
    {
        // This is the constructor for the player entity.
        public PlayerEntity()
        {
        }

        // These properties indicate the X, Y and Z position of the entity.
        public float X { get; set; }
        public float Y { get; set; }
        public float Z { get; set; }

        // This is the update method called by the world manager during the update loop.
        public void Update(IGameContext gameContext, IUpdateContext updateContext)
        {
        }

        // This is the render method called by the world manager during the render loop.
        public void Render(IGameContext gameContext, IRenderContext renderContext)
        {
        }
    }
}

Add a new class to your project that matches this definition, such that the entity is called PlayerEntity.

Add a factory method

To create entities at runtime while still allowing them to be dependency injected, you need to create a factory method. The implementation of the factory is automatically provided to you by Protogame; you just need to add the method so that you have a way of instantiating the entity.

Modify the IEntityFactory interface in the project so that it has a method to create a player entity:

using System;
using Protoinject;

namespace MyGame
{
    public interface IEntityFactory : IGenerateFactory
    {
        ExampleEntity CreateExampleEntity(string name);
        
        PlayerEntity CreatePlayerEntity();
    }
}

Creating the player entity

Now that we have set up our interfaces, we can begin to create the entity in our existing world.

Modify the constructor of the world to create an instance of PlayerEntity using the new CreatePlayerEntity method.

The world’s constructor should now look similar to this:

public MyGameWorld(
    I2DRenderUtilities twoDRenderUtilities,
    IAssetManagerProvider assetManagerProvider,
    IEntityFactory entityFactory)
{
    this.Entities = new List<IEntity>();

    _renderUtilities = twoDRenderUtilities;
    _assetManager = assetManagerProvider.GetAssetManager();
    _defaultFont = this._assetManager.Get<FontAsset>("font.Default");

    // You can also save the entity factory in a field and use it, e.g. in the Update
    // loop or anywhere else in your game.
    var entityA = entityFactory.CreateExampleEntity("EntityA");
    entityA.X = 100;
    entityA.Y = 50;
    var entityB = entityFactory.CreateExampleEntity("EntityB");
    entityB.X = 120;
    entityB.Y = 100;

    // Don't forget to add your entities to the world!
    this.Entities.Add(entityA);
    this.Entities.Add(entityB);

    // This pulls in the texture asset via the asset manager.  Note that
    // the folder seperator from "texture/Player" has been translated
    // into a single dot.
    _playerTexture = _assetManager.Get<TextureAsset>("texture.Player");

    // Add the player entity.
    this.Entities.Add(entityFactory.CreatePlayerEntity());
}

Testing the player

If we now run the game and set a breakpoint in the IDE appropriately (as indicated by the screenshot below), we will see the player entity in the world’s entity list:

If we place a breakpoint on the entity’s Update method, we can see that it is also hit as the game runs:

Rendering the player

Now let’s make our entity appear on screen. To do so, we need to render a texture as part of entity’s Render call.

The process is very similar to what is described in Rendering textures. If you have not read that walkthrough, we highly recommend you do so.

In the same way that we rendered a texture in the world, we’re going to render a texture in the entity. To recap, we needed to follow four steps:

1. Inject the I2DRenderUtilities interface. This provides the API to render the texture.
2. Inject the IAssetManagerProvider interface. From this we can gain access to the asset manager, and from there gain access to our texture asset.
3. Gain a reference to the texture asset within the entity’s constructor.
4. Call the RenderTexture method against I2DRenderUtilities within the render loop.

Adjusting the render code

This results in an entity definition that looks similar to the following:

using System;
using Microsoft.Xna.Framework;
using Protogame;

namespace MyProject
{
    public class PlayerEntity : IEntity
    {
        // This is the field where we keep a reference to the 2D render utilities.
        private readonly I2DRenderUtilities m_2DRenderUtilities;

        // This is the field where we keep a reference to the player texture we will render.
        private readonly TextureAsset m_PlayerTexture;

        // This is the player constructor.  Both parameters are automatically dependency
        // injected when we call CreatePlayerEntity on the entity factory.
        public PlayerEntity(
            I2DRenderUtilities twodRenderUtilities,
            IAssetManagerProvider assetManagerProvider)
        {
            // Keep the 2D render utilities around for later.
            this.m_2DRenderUtilities = twodRenderUtilities;

            // Some implementations might assign the asset manager to a field, depending on
            // whether or not they need to look up assets during the update or render
            // loops.  In this case we just need access to one texture, so we just keep
            // it in a local variable for easy access.
            var assetManager = assetManagerProvider.GetAssetManager();

            // Retrieve the player texture.
            this.m_PlayerTexture = assetManager.Get<TextureAsset>("texture.Player");
        }

        public float X { get; set; }
        public float Y { get; set; }
        public float Z { get; set; }

        public void Update(IGameContext gameContext, IUpdateContext updateContext)
        {
        }

        public void Render(IGameContext gameContext, IRenderContext renderContext)
        {
            // This check is not strictly required when using a 2D world manager, but it
            // is recommended in case you want to change to a 3D world manager later on
            // down the track.
            //
            // You can not use I2DRenderUtilities when the render context is 3D (and
            // vica-versa; you can not use I3DRenderUtilities when the render context
            // is 2D).
            if (renderContext.Is3DContext)
            {
                return;
            }

            // Render the texture at our current position.
            this.m_2DRenderUtilities.RenderTexture(
                renderContext,
                new Vector2(this.X, this.Y),
                this.m_PlayerTexture);
        }
    }
}

Viewing the result

If you now run the game, you will see the following on your screen:

Warning

The texture being rendered at position 100, 100 is due to the render texture call made in the world. You will see this if you are following on directly from the rendering textures tutorial. The texture in the top left of the screen is the texture being rendered by the player entity (due to it’s X and Y position being initially 0, 0).

Updating the player

Now that we have our player entity rendering, let’s do something with it. We won’t yet cover handling input from the player (that is discussed in Handling input), but we will make it move around the screen on it’s own.

We are going to make the following changes to our entity:

• It will be initially positioned at 300, 300.
• We will make it’s X position the result of a sine wave, with an increasing counter as the input value.

Modify the entity’s code so that Update loop matches the following code, and that the specified field is defined:

// This is our new counter field that we increment every frame.
private float m_Counter = 0;

public void Update(IGameContext gameContext, IUpdateContext updateContext)
{
    // Increments the counter.
    this.m_Counter++;

    // Adjust the X and Y position so that the X position deviates 50
    // pixels either side of 300 as the game updates.
    this.X = 300 + (float)Math.Sin(MathHelper.ToRadians(this.m_Counter)) * 50;
    this.Y = 300;
}

Viewing the animation

When running the game, you should get a result that looks similar to the following video:

Next steps

We recommend continuing onto the next walkthough, Handling input.

Handling input

Danger

These walkthroughs currently need to be updated to reflect the new render pipeline functionality in Protogame.

Warning

For this walkthrough, we are assuming you are following on from the Add a player walkthrough.

In the “add a player” tutorial, we introduced the concepts of defining and creating entities, as well as performing rendering and updating for them. However, we are still missing one crucial component left for a game; that is, the ability to accept input from the player and react to it.

Traditional XNA or MonoGame games directly access the abstracted hardware APIs such as MouseState and KeyboardState to determine what input the player is provided. While this works for simple scenarios, it quickly becomes unfeasible when you have the potential for multiple entities or UI elements to be accepting input and you only want one entity to react to the player’s actions.

To this end, Protogame provides an event system which uses bindings to map player inputs to actions that the game should take. The event system is the recommended way of accepting input in a Protogame-based game (but you do not have to use it).

Adding the module

In order to use the events system, we have to load it’s module into the dependency injection kernel. Modify the contents of your Program.cs file so that the initialization of the kernel looks like the following:

var kernel = new StandardKernel();
kernel.Load<Protogame2DIoCModule>();
kernel.Load<ProtogameAssetIoCModule>();
kernel.Load<ProtogameEventsIoCModule>(); // Load the events module
kernel.Load<MyProjectModule>(); // This was added in the previous tutorial
AssetManagerClient.AcceptArgumentsAndSetup<GameAssetManagerProvider>(kernel, args);

We can now use the events system.

Creating an event binder

The events system allows multiple event binders to be registered (through dependency injection). The most commonly used binder is the StaticEventBinder, which uses a fluent syntax for allowing the developer to map input to actions.

That said, you can derive from the IEventBinder interface and implement another mechanism for mapping inputs to actions. You will most likely want to do this when you want to allow the player to remap inputs.

However, implementation of a custom IEventBinder is outside the scope of this walkthrough, so we will be deriving from StaticEventBinder and registering it.

First, we need to create a new class called MyProjectEventBinder (adjusting the project name appropriately), with the following content:

using System;
using Protogame;

namespace MyProject
{
    public class MyProjectEventBinder : StaticEventBinder<IGameContext>
    {
        public override void Configure()
        {
            // We haven't defined any bindings yet.
        }
    }
}

Now let’s register it in our dependency injection module. Modify the Load method of MyProjectModule such that it looks like:

using System;
using Ninject.Extensions.Factory;
using Ninject.Modules;
using Protogame;

namespace MyProject
{
    public class MyProjectModule : NinjectModule
    {
        public override void Load()
        {
            // This was added in the previous tutorial.
            this.Bind<IEntityFactory>().ToFactory();

            // Our new event binder.
            this.Bind<IEventBinder<IGameContext>>().To<MyProjectEventBinder>();
        }
    }
}

Creating actions

We will now define an action that the player can take. This is seperate from the actual input the player will provide, but indicates what should occur.

Event bindings can target one of multiple things; you can have bindings map inputs to actions, entity actions, commands or listeners.

In this case we want to perform an action against a type of entity, where we are expecting only one entity of this type to be in the world. Thus we can use an entity action and simplify our logic drastically, since the event binder will take care of locating the entity and passing it in as a parameter.

To start, we are going to define four actions for moving our entity. We have placed these four actions in one file for the walkthrough’s simplicity, although the normal convention is to have one class per file. Add the following content to a file called MoveActions.cs:

using System;
using Protogame;

namespace MyProject
{
    public class MoveUpwardAction : IEventEntityAction<PlayerEntity>
    {
        public void Handle(IGameContext context, PlayerEntity entity, Event @event)
        {
            entity.Y -= 4;
        }
    }

    public class MoveDownwardAction : IEventEntityAction<PlayerEntity>
    {
        public void Handle(IGameContext context, PlayerEntity entity, Event @event)
        {
            entity.Y += 4;
        }
    }

    public class MoveLeftAction : IEventEntityAction<PlayerEntity>
    {
        public void Handle(IGameContext context, PlayerEntity entity, Event @event)
        {
            entity.X -= 4;
        }
    }

    public class MoveRightAction : IEventEntityAction<PlayerEntity>
    {
        public void Handle(IGameContext context, PlayerEntity entity, Event @event)
        {
            entity.X += 4;
        }
    }
}

Binding input to actions

Now that we have defined both our event binder and our actions, we can create our input bindings.

Modify the event binder so that the Configure method looks like the following:

using System;
using Microsoft.Xna.Framework.Input;
using Protogame;

namespace MyProject
{
    public class MyProjectEventBinder : StaticEventBinder<IGameContext>
    {
        public override void Configure()
        {
            this.Bind<KeyHeldEvent>(x => x.Key == Keys.Up).On<PlayerEntity>().To<MoveUpwardAction>();
            this.Bind<KeyHeldEvent>(x => x.Key == Keys.Down).On<PlayerEntity>().To<MoveDownwardAction>();
            this.Bind<KeyHeldEvent>(x => x.Key == Keys.Left).On<PlayerEntity>().To<MoveLeftAction>();
            this.Bind<KeyHeldEvent>(x => x.Key == Keys.Right).On<PlayerEntity>().To<MoveRightAction>();
        }
    }
}

In the code above, we bind various “key held events”, (that is, they fire while the player holds a key down) onto the PlayerEntity instance in the world, with the specified action being invoked against the instance of the PlayerEntity.

Modify the player entity

Before we go any further, we need to remove the modifications to the player entity that cause it’s position to be updated automatically every step.

Danger

If you leave this code in, you won’t see the effects of your keyboard presses, as the result will be immediately reset when the entity updates.

If you followed the previous tutorial, your player entity might have it’s Update method defined as:

// This is our new counter field that we increment every frame.
private float m_Counter = 0;

public void Update(IGameContext gameContext, IUpdateContext updateContext)
{
    // Increments the counter.
    this.m_Counter++;

    // Adjust the X and Y position so that the X position deviates 50
    // pixels either side of 300 as the game updates.
    this.X = 300 + (float)Math.Sin(MathHelper.ToRadians(this.m_Counter)) * 50;
    this.Y = 300;
}

Remove the above code so that it becomes it’s original form:

public void Update(IGameContext gameContext, IUpdateContext updateContext)
{
}

Testing the result

With the event bindings now set up, you should be able to run the game and see something similar to the following video:

Conclusion

For now, this ends the series of basic walkthroughs on getting started with Protogame. We’ve covered the basics, such as rendering graphics, entity management and handling input.

Note

Is there something we’ve missed or didn’t cover? Please let me know!

Engine API

This documentation covers the core concepts of the engine, as well as the APIs that are available for use. It is organised into sections that roughly correlate with various aspects of the engine; core structure, graphics APIs, networking, etc.

Core: Architecture

This area of the Protogame documentation covers core concepts of the engine, such as how games are initialized and how Protogame manages the game lifecycle.

Game startup

When writing a game in Protogame, you’ll need to configure your program’s entry point so that the game initializes correctly.

Dependency injection

Dependency injection is a core concept of Protogame; it allows games to be built in an extremely flexible and scalable way, without locking down early design or architectural decisions.

Dependency injection does have a cost in game development, often it takes a little longer to wire up new systems as you’ll need to register them in the dependency injection kernel at startup. However, dependency injection significantly pays off in the long term as it almost completely eliminates the need for large refactors; any system which is to be replaced can be done so gracefully by providing a shim for older interfaces.

The usage of dependency injection is what allows your games to scale in Protogame from the prototyping stage to full development, without throwing away prototype code. You can gradually migrate away from your prototype code one system at a time, without being forced to do a “big bang” approach to refactors.

Quick summary

Dependency injection involves two main tasks:

• Registering an interface to an implementation in the kernel
• Adding the dependencies of your implementation to it’s constructor

We’ll go into more details on each of these concepts in the next sections, but a very rough summary of what both of these look like in code follows. To register an interface in the kernel, you’d add the following binding code either to the program startup, or inside a dependency injection module:

Bind<ISomeInterface>().To<DefaultSomeImplementation>();

then in the class where you want to use the functionality of the interface or implementation, you would inject it into your class constructor like so:

public class MyClass
{
    public MyClass(ISomeInterface someInterface)
    {
        // Either use someInterface or store it in a private readonly field.
    }
}

Now you can see how this allows systems within your game to be changed out extremely easily; when you need to change the implementation of a system you only need to change it in one place: at the point of binding.

For example, you could implement your player movement calculation code in an IPlayerMovement interface and DefaultPlayerMovement implementation. In C# you would make DefaultPlayerMovement implement IPlayerMovement, and write the appropriate calculation code inside the implementation. Later on in development if you want to start trialling a new movement system, you don’t need to replace or directly change the existing implementation; you can create a new implementation like NewPlayerMovement (preferably more sensibly named), and change the binding to bind to NewPlayerMovement instead. Now everywhere in your game that uses player movement will start using the new code, without any refactoring.

In depth: Binding services

TODO

In depth: Injecting services

TODO

Creating game entities with factories

TODO

Updating and rendering

Core: Services and APIs

This section of the documention details the core APIs provided by Protogame.

CoreGame<TInitialWorld>

class CoreGame<TInitialWorld> : Protogame.CoreGame<TInitialWorld, RenderPipelineWorldManager>, System.IDisposable, Protogame.ICoreGame

The core Protogame game implementation. You should derive your Game class from this implementation.

Type Parameters:  

• TInitialWorld – The initial world class to start the game with.

protected abstract void ConfigureRenderPipeline(IRenderPipeline pipeline, IKernel kernel)

Configure the render pipeline before the game begins.

In the new rendering system, you need to add render passes to the render pipeline of your game to indicate how things will be rendered. Use M:Protogame.IRenderPipeline.AddFixedRenderPass(Protogame.IRenderPass) or M:Protogame.IRenderPipeline.AppendTransientRenderPass(Protogame.IRenderPass) to add passes to the render pipeline.

Parameters:

• pipeline (Protogame.IRenderPipeline) – The render pipeline to configure.
• kernel (Protoinject.IKernel) – The dependency injection kernel, on which you can call Get on to create new render passes for adding to the pipeline.

Entity

class Entity : System.Object, Protogame.IBoundingBox, IHasTransform, IHasSize, IHasVelocity, IEntity

The default implementation of a game entity that doesn’t use components. You can inherit from this class to make implementing T:Protogame.IEntity easier.

float Depth

Gets or sets the depth.

Value:The depth.

float Height

Gets or sets the height.

Value:The height.

float Width

Gets or sets the width.

Value:The width.

float XSpeed

Gets or sets the x speed.

Value:The x speed.

float YSpeed

Gets or sets the y speed.

Value:The y speed.

float ZSpeed

Gets or sets the z speed.

Value:The z speed.

readonly Protogame.ITransform Transform

readonly Protogame.IFinalTransform FinalTransform

public void Render(IGameContext gameContext, IRenderContext renderContext)

The render.

Parameters:

• gameContext (Protogame.IGameContext) – The game context.
• renderContext (Protogame.IRenderContext) – The render context.

public void Update(IGameContext gameContext, IUpdateContext updateContext)

The update.

Parameters:

• gameContext (Protogame.IGameContext) – The game context.
• updateContext (Protogame.IUpdateContext) – The update context.

HasTransformExtensions

class HasTransformExtensions : System.Object

Extension methods which assist developers in writing classes that implement T:Protogame.IHasTransform.

public Protogame.IFinalTransform GetAttachedFinalTransformImplementation(IHasTransform hasTransform, INode node)

Returns a final transform by combining the final transform of the parent in the hierarchy (if the parent node has a transform), and the local transform of this object. You should use this method to implement P:Protogame.IHasTransform.FinalTransform if your object resides in the hierarchy.

Parameters:

• hasTransform (Protogame.IHasTransform) – The current object.
• node (Protoinject.INode) – The node in the dependency injection hierarchy that points to this object. This value can be obtained by injecting T:Protoinject.INode into the constructor of your object.

Returns:

A final computed transform.

public Protogame.IFinalTransform GetDetachedFinalTransformImplementation(IHasTransform hasTransform)

Gets a final transform which is just representative of the local transform. This method should be used sparingly, but is intended when either you know the parent of this object will have no transform (i.e. you are implementing an entity which resides directly in the world), or when there’s no way for the caller to know it’s position in the hierarchy.

Parameters:

• hasTransform (Protogame.IHasTransform) – The current object.

Returns:

A final computed transform.

IEngineHook

interface IEngineHook

An interface representing a low-level engine hook. These hooks are should be registered in the dependency injection container. All registered engine hooks will be automatically fired during execution of the game.

void Render(IGameContext gameContext, IRenderContext renderContext)

The render callback for the engine hook. This is triggered right before the rendering of the world manager.

Parameters:

• gameContext (Protogame.IGameContext) – The game context.
• renderContext (Protogame.IRenderContext) – The render context.

void Update(IGameContext gameContext, IUpdateContext updateContext)

The update callback for the engine hook. This is triggered right before the update of the world manager.

Parameters:

• gameContext (Protogame.IGameContext) – The game context.
• updateContext (Protogame.IUpdateContext) – The update context.

void Update(Protogame.IServerContext serverContext, IUpdateContext updateContext)

The update callback for the engine hook on a server. This is triggered right before the update of the world manager.

Parameters:

• serverContext (Protogame.IServerContext) – The server context.
• updateContext (Protogame.IUpdateContext) – The update context.

IEntity

interface IEntity : IHasTransform

Represents an entity.

For a base implementation that has the required interfaces implemented, inherit from T:Protogame.Entity.

For a base implementation that supports components, inherit from T:Protogame.ComponentizedEntity.

void Render(IGameContext gameContext, IRenderContext renderContext)

Called by the T:Protogame.IWorldManager when it’s time for this entity to be rendered in the game.

Parameters:

• gameContext (Protogame.IGameContext) – The game context.
• renderContext (Protogame.IRenderContext) – The render context.

void Update(IGameContext gameContext, IUpdateContext updateContext)

Called by the T:Protogame.IWorldManager when this entity’s state should be updated in the game.

Parameters:

• gameContext (Protogame.IGameContext) – The game context.
• updateContext (Protogame.IUpdateContext) – The update context.

IGameConfiguration

interface IGameConfiguration

The game configuration interface. All of the implementations of T:Protogame.IGameConfiguration are instantiated at startup and are used to configure the dependency injection system and the game.

void ConfigureKernel(IKernel kernel)

Called at application startup to configure the kernel before the game is created.

Parameters:

• kernel (Protoinject.IKernel) – The dependency injection kernel.

Game ConstructGame(IKernel kernel)

Called at application startup to construct the main game instance. This instance will be run as the main game.

Parameters:

• kernel (Protoinject.IKernel) – The dependency injection kernel.

Returns:

The game instance to run.

IGameContext

interface IGameContext

Represents the state of the game at runtime. This interface is frequently used, and is passed in to Render and Update methods of all worlds and entities.

int FPS

Gets the frames-per-second of the current game.

Value:The FPS.

int FrameCount

Gets the number of frames that have been rendered in total during the game.

Value:The total number of frames rendered.

readonly Game Game

Gets the game instance.

Value:The game instance.

GameTime GameTime

Gets the amount of game time elapsed since the last update or render step.

Value:The elapsed game time since the last update or render step.

readonly GraphicsDeviceManager Graphics

Gets the graphics device manager, which provide a high-level API to the graphics device.

Value:The graphics device manager.

readonly Protogame.IGameWindow Window

Gets the game window.

Value:The window the game is rendering in.

readonly IWorld World

Gets the current world.

Value:The current active world in the game.

readonly IWorldManager WorldManager

Gets the world manager.

Value:The world manager.

readonly IHierarchy Hierarchy

Gets the dependency injection hierarchy, which contains all worlds, entities and components.

Value:The dependency injection hierarchy, which contains all worlds, entities and components.

Ray MouseRay

Gets or sets the ray representing the mouse cursor in 3D space. This is updated automatically by DefaultRenderContext based on the World, View and Projection properties of the current render context.

Value:The ray representing the mouse cursor in 3D space.

Plane MouseHorizontalPlane

Gets or sets the plane representing the mouse cursor’s Y position in 3D space. This forms a plane such that if it were projected back to the screen it would intersect the mouse’s Y position along the X axis of the screen. This is updated automatically by DefaultRenderContext based on the World, View and Projection properties of the current render context.

Value:The plane representing the mouse cursor’s Y position in 3D space.

Plane MouseVerticalPlane

Gets or sets the plane representing the mouse cursor’s X position in 3D space. This forms a plane such that if it were projected back to the screen it would intersect the mouse’s X position along the Y axis of the screen. This is updated automatically by DefaultRenderContext based on the World, View and Projection properties of the current render context.

Value:The plane representing the mouse cursor’s X position in 3D space.

void Begin()

Called by the game at the beginning of a frame, immediately before any update logic is processed. This method is used by the engine, and should not be called from user code.

IWorld CreateWorld<T>()

Creates the specified world and returns it.

Type Parameters:  

• T – The type of the world to create.

Returns:

The T:Protogame.IWorld.

IWorld CreateWorld<TFactory>(System.Func<TFactory, IWorld> creator)

Creates the specified world using a given factory and returns it.

Type Parameters:  

• TFactory – The type of the world to create.

Parameters:

• IWorld> creator (System.Func<TFactory,) – The method used to create the world.

Returns:

The T:Protogame.IWorld.

void ResizeWindow(int width, int height)

Resizes the game window to the specified width and height. This method can only be called during the update step (not during rendering).

Parameters:

• width (int) – The desired width of the game window.
• height (int) – The desired height of the game window.

void SwitchWorld<T>()

Asynchronously switches the current active world to a new instance of the world, as specified by the given type.

Type Parameters:  

• T – The type of world to create and switch to.

void SwitchWorld<TFactory>(System.Func<TFactory, IWorld> creator)

Switches the current active world to a new instance of the world, using the specified factory method to create the instance of the world.

Type Parameters:  

• TFactory – The type of world to create and switch to.

Parameters:

• IWorld> creator (System.Func<TFactory,) – The factory method used to create the world.

void SwitchWorld<TFactory>(System.Func<TFactory, Task`1> creator)

Asynchronously switches the current active world to a new instance of the world, using the specified factory method to create the instance of the world.

Type Parameters:  

• TFactory – The type of world to create and switch to.

Parameters:

• Task`1> creator (System.Func<TFactory,) – The factory method used to create the world.

void SwitchWorld<T>(Protogame.T world)

Type Parameters:  

• T –

Parameters:

• world (Protogame.T) –

IHasSize

interface IHasSize

An interface which indicates that an object has a bounding box size assocated with it.

float Depth

Gets or sets the depth.

Value:The depth.

float Height

Gets or sets the height.

Value:The height.

float Width

Gets or sets the width.

Value:The width.

IHasTransform

interface IHasTransform

An interface which indicates that an object has a transform associated with it.

readonly Protogame.ITransform Transform

The local transform of this object.

readonly Protogame.IFinalTransform FinalTransform

The final transform of this object.

If you’re implementing this property, you probably want to use M:Protogame.HasTransformExtensions.GetAttachedFinalTransformImplementation(Protogame.IHasTransform,Protoinject.INode) or M:Protogame.HasTransformExtensions.GetDetachedFinalTransformImplementation(Protogame.IHasTransform).

IHasVelocity

interface IHasVelocity

An interface which indicates that an object has a velocity associated with it.

float XSpeed

Gets or sets the X speed.

Value:The X speed.

float YSpeed

Gets or sets the Y speed.

Value:The Y speed.

float ZSpeed

Gets or sets the Z speed.

Value:The Z speed.

IRenderContext

interface IRenderContext

An interface which provides the current context in which rendering is being performed. This is passed to all Render methods by the engine.

You should avoid performing calls to MonoGame’s rendering APIs unless you have an accessible instance of T:Protogame.IRenderContext. Without having an instance of T:Protogame.IRenderContext, it’s possible that the code you are writing will be invoked outside of the standard rendering loop.

readonly BoundingFrustum BoundingFrustum

Gets the bounding frustum for the current view and projection matrixes.

Value:The bounding frustum for the current view and projection matrixes.

readonly GraphicsDevice GraphicsDevice

Gets the associated graphics device.

Value:The graphics device.

bool IsRendering

Gets a value indicating whether the game is currently rendering in either the render pipeline or the backbuffer. This value will always be true within any method call that occurs below M:Microsoft.Xna.Framework.Game.Draw(Microsoft.Xna.Framework.GameTime) in the call stack. When you are rendering, certain operations can not be performed, in particular, operations which reset the graphics device like resizing the game window.

Vector3 CameraPosition

Gets or sets the last known camera position. The value of this property is set internally by cameras so that the camera position is known when lighting effects are applied. Setting this property from user code will not actually update the camera position or modify projection parameters; it will only impact the way lights are rendered.

Vector3 CameraLookAt

Gets or sets the last known camera look at vector. The value of this property is set internally by cameras so that the camera look at vector is known when lighting effects are applied. Setting this property from user code will not actually update the camera look at vector or modify projection parameters; it will only impact the way lights are rendered.

Matrix Projection

Gets or sets the projection matrix for 3D rendering.

Value:The projection matrix for 3D rendering.

readonly Texture2D SingleWhitePixel

Gets a texture representing a single white pixel.

Value:The single white pixel.

readonly SpriteBatch SpriteBatch

Gets a sprite batch associated with the current device, upon which 2D rendering is performed.

Value:The sprite batch.

Matrix View

Gets or sets the view matrix for 3D rendering.

Value:The view matrix for 3D rendering.

Matrix World

Gets or sets the world matrix for 3D rendering.

Value:The world matrix for 3D rendering.

readonly IRenderPass CurrentRenderPass

Gets the current render pass that is being used.

Value:The current render pass that is being used.

void PopRenderTarget()

Pops the current render target from the current rendering context. If there are no more render targets in the stack after this call, then the rendering will default back to rendering to the back buffer.

void PushRenderTarget(RenderTargetBinding renderTarget)

Push a render target onto the current rendering context, making it the active target for rendering. By using the PushRenderTarget / PopRenderTarget methods, this allows you to safely chain render target switches, without risk of losing the previous render target. An example of where this can be used is if you want to capture the next frame, you can simply start with a PushRenderTarget and as long as all other render target switching uses these methods or respects the previous render target, then everything will be captured as intended.

Parameters:

• renderTarget (Microsoft.Xna.Framework.Graphics.RenderTargetBinding) – The render target instance to make active.

void PushRenderTarget(Microsoft.Xna.Framework.Graphics.RenderTargetBinding[] renderTargets)

Push an array of render targets onto the current rendering context, making them the active target for rendering. By using the PushRenderTarget / PopRenderTarget methods, this allows you to safely chain render target switches, without risk of losing the previous render target.

Parameters:

• renderTargets (Microsoft.Xna.Framework.Graphics.RenderTargetBinding[]) – The render targets to make active.

void Render(IGameContext context)

Called by the world manager to set up the render context at the beginning of a render.

Parameters:

• context (Protogame.IGameContext) – The current game context.

IRenderPass AddFixedRenderPass(IRenderPass renderPass)

Adds the specified render pass to the render pipeline permanently. This render pass will take effect after the start of the next frame.

Parameters:

• renderPass (Protogame.IRenderPass) – The render pass to add.

Returns:

The render pass that was given to this function. This return value is for convenience only, so that you may construct and add a render pass in a single statement, while obtaining a reference to it if you need to modify it’s values or call M:Protogame.IRenderContext.RemoveFixedRenderPass(Protogame.IRenderPass) later. The render pass is not modified by this function.

void RemoveFixedRenderPass(IRenderPass renderPass)

Removes the specified render pass from the render pipeline.

Parameters:

• renderPass (Protogame.IRenderPass) – The render pass to remove.

IRenderPass AppendTransientRenderPass(IRenderPass renderPass)

Append the specified render pass to the render pipeline for this frame only. This is method that allows you to temporarily add additional render passes to a frame.

If all standard (non-post-processing) render passes have finished post-processing has begun and this method is given a standard render pass, it will have no effect.

Render passes that were appended can not be removed with M:Protogame.IRenderContext.RemoveFixedRenderPass(Protogame.IRenderPass).

Parameters:

• renderPass (Protogame.IRenderPass) – The render pass to add.

Returns:

The render pass that was given to this function. This return value is for convenience only, so that you may construct and add a render pass in a single statement, while obtaining a reference to it if you need to modify it’s value. The render pass is not modified by this function.

bool IsCurrentRenderPass<T>()

Returns whether or not the current render pass is of the specified type.

Type Parameters:  

• T – The type to check the render pass against.

Returns:

Whether or not the current render pass is of the specified type.

bool IsCurrentRenderPass<T>(ref Protogame.T currentRenderPass)

Type Parameters:  

• T –

Parameters:

• (ref) currentRenderPass (Protogame.T) –

Protogame.T GetCurrentRenderPass<T>()

Returns the current render pass as the type T.

Type Parameters:  

• T – The type of render pass to return.

Returns:

The current render pass as the type T.

bool IsFirstRenderPass()

Returns whether this is the first render pass being performed. You can use this method to isolate render logic that should only occur once per frame (such as appending transient render passes).

Returns:Whether this is the first render pass being performed.

IServerConfiguration

interface IServerConfiguration

The server configuration interface. All of the implementations of T:Protogame.IServerConfiguration are instantiated at startup and are used to configure the dependency injection system and the server.

void ConfigureKernel(IKernel kernel)

Called at application startup to configure the kernel before the server is created.

Parameters:

• kernel (Protoinject.IKernel) – The dependency injection kernel.

Protogame.ICoreServer ConstructServer(IKernel kernel)

Called at application startup to construct the main server instance. This instance will be run as the main server.

Parameters:

• kernel (Protoinject.IKernel) – The dependency injection kernel.

Returns:

The server instance to run.

IStringSanitizer

interface IStringSanitizer

An interface which provides mechanisms to sanitize text input.

string SanitizeCharacters(SpriteFont font, string text)

Sanitizes the specified text such that it can be rendered with the specified font.

Parameters:

• font (Microsoft.Xna.Framework.Graphics.SpriteFont) – The font that will render or measure the text.
• text (string) – The text to sanitize.

Returns:

The text containing only characters that the font can render.

IUpdateContext

interface IUpdateContext

The UpdateContext interface.

This interface provides a mechanism to perform additional update logic based on the current state of the game.

Bind this interface in the Protoinject kernel before creating an instance of your game, and the T:Protogame.CoreGame`1 implementation will create an instance of the bound type and use it during execution.

void Update(IGameContext context)

The update.

Parameters:

• context (Protogame.IGameContext) – The context.

IWorld

interface IWorld : System.IDisposable

The World interface.

A world is a container for the entities and logic of the current game state. It encapsulates the general appearance and logic of the game while the world is active (unlike T:Protogame.IWorldManager which applies throughout the execution of the entire game).

This is an interface which all of the worlds you define should implement.

void RenderAbove(IGameContext gameContext, IRenderContext renderContext)

This is called by T:Protogame.IWorldManager when rendering is about to finish. Rendering has not yet been completely finalized, but all entities have been rendered in the current context.

Parameters:

• gameContext (Protogame.IGameContext) – The game context.
• renderContext (Protogame.IRenderContext) – The render context.

void RenderBelow(IGameContext gameContext, IRenderContext renderContext)

This is called by T:Protogame.IWorldManager when rendering has started, but no entities have yet been rendering in the current context.

Parameters:

• gameContext (Protogame.IGameContext) – The game context.
• renderContext (Protogame.IRenderContext) – The render context.

void Update(IGameContext gameContext, IUpdateContext updateContext)

This is called by T:Protogame.IWorldManager after all of the entities have been updated.

Parameters:

• gameContext (Protogame.IGameContext) – The game context.
• updateContext (Protogame.IUpdateContext) – The update context.

IWorldManager

interface IWorldManager

The WorldManager interface.

A world manager handles the main game loop; that is, is the top most object responsible for rendering and updating the game. Within a world manager, you will call Render and Update on the current world, usually after setting up the appropriate rendering contexts.

There is a default world manager implementation bound when loading the T:Protogame.ProtogameCoreModule. You can rebind this interface to perform advanced rendering or update logic.

void Render<T>(Protogame.T game)

Type Parameters:  

• T –

Parameters:

• game (Protogame.T) –

void Update<T>(Protogame.T game)

Type Parameters:  

• T –

Parameters:

• game (Protogame.T) –

ProtogameCoreModule

class ProtogameCoreModule : ProtogameBaseModule, IProtoinjectModule

The core Protogame dependency injection module, which loads all of the core classes required for basic game functionality. You must load this module for Protogame to work.

public void Load(IKernel kernel)

You should call M:Protoinject.StandardKernel.Load``1 instead of calling this method directly.

Parameters:

• kernel (Protoinject.IKernel) –

Asset Management

Protogame uses the concept of assets to distinguish between logic / code and data / assets. Unlike other engines, assets are intended to be used to define not only low-level data such as textures, but also types of things in your game, such as different types or enemies.

Examples of assets common to all Protogame games are:

• Textures
• Sounds
• 3D models
• Effects (shaders)
• AI logic
• Ogmo Editor levels

Examples of custom assets that you might define for your game are:

• Enemy types
• Spells
• Weapons

Conceptual model

The diagram below outlines the conceptual model of the asset system, including how assets are stored, compiled and loaded:

Using assets

To use assets in-game, you need to inject IAssetManagerProvider and call GetAssetManager() on it. This is covered in detail in the Rendering textures walkthough, and as such is not covered here.

Types of assets

Textures

Textures can be provided in source form with a standard PNG image. They represent images that can be rendered at runtime in your game.

Textures are platform-specific and thus they require compilation. When the game is running on a desktop platform, compilation can be done transparently from the PNG file specified, but for either mobile or release builds you need to compile texture assets using the Protogame asset tool.

Sounds

Sounds are used for playing back audio during the game. Sounds are provided in a standard Wave format. This format is reasonably specific due to the requirement for it to be playable across platforms.

As specified in the XNA documentation, the requirements for the Wave format are:

Note

The Stream object must point to the head of a valid PCM wave file. Also, this wave file must be in the RIFF bitstream format.

The audio format has the following restrictions:

• Must be a PCM wave file
• Can only be mono or stereo
• Must be 8 or 16 bit
• Sample rate must be between 8,000 Hz and 48,000 Hz

Sounds are platform-specific and thus they require compilation. When the game is running on a desktop platform, compilation can be done transparently from the Wave file specified, but for either mobile or release builds you need to compile sound assets using the Protogame asset tool.

3D Models

3D models are used to render shapes when building a 3D game. They are provided in source form with an FBX file, and have support for animations in this format.

3D models must be converted into a format for fast loading at runtime and thus they require compilation. The library that reads FBX files runs on desktop platforms and thus FBX files can be read at runtime on these platforms, but for either mobile or release builds you need to compile model assets using the Protogame asset tool.

Effects

Effects are cross-platform shaders that are written in a format similar to HLSL and are provided in a .fx file on disk. Since effects are written in a derivative of HLSL, effects can only be compiled on a Windows machine.

Protogame provides a remote compilation mechanism that allows effects to be sent from a non-Windows machine (such as Linux) over the network, compiled on a Windows machine for the appropriate target type, returned and loaded transparently. For more information, see Remote compilation.

Sounds are platform-specific and thus they require compilation. When the game is running on a desktop platform, compilation can be done transparently from the effect file specified, but for either mobile or release builds you need to compile effect assets using the Protogame asset tool.

AI logic

Unlike other forms on assets, AIs are defined as classes in your code and carry the [Asset("name")] attribute on the class declaration, while also inheriting from AIAsset. An example of an AI asset that does not perform any functionality would be as follows:

AI assets do not require any additional processing to work as they are compiled as part of your codebase. AI assets are designed as a way for custom assets (such as enemy types) to specify how they should behave in the game.

Ogmo Editor Levels

Ogmo Editor levels are saved as .oel files by Ogmo Editor. .oel files can be read and loaded on any platform, and are internally converted to normal source asset files. When you compile assets, the result will be an .asset file that embeds the original level file’s data.

Compiling assets

As mentioned above, some types of assets require compilation before they can be used. This can happen at runtime for desktop platforms in Debug mode, but you must precompile assets for mobile or release builds.

To compile assets, we use the Protogame asset tool, which is included in the solution you use to build your game.

The Protogame asset tool accepts the following options to determine how it will compile assets:

Option	Description
-o ...\MyProject.Content\compiled	This should be the “compiled” folder in your content project. It specifies the location to output the compiled assets for each target platform.
-p Windows -p Linux ...	This option is specified for each platform you want to target. If you wanted to target Linux and Android, you would specify -p Linux -p Android. The supported platform names are (these are from the TargetPlatform enumeration in Protogame): Windows Xbox360 WindowsPhone iOS Android Linux MacOSX WindowsStoreApp NativeClient Ouya PlayStationMobile WindowsPhone8 RaspberryPi
-a MyAssembly.dll --assembly=MyAssembly.dll	This specifies additional assemblies to load during asset compilation. This is required if you have defined custom asset types as the Protogame asset tool needs to know where to locate the loader, saver and (optionally) compiler classes for the custom assets.
-m remote	This changes the behaviour of the Protogame asset tool so that instead of compiling assets, it instead listens for remote requests for asset compilation. See the Remote compilation section for more information on remote effect compilation.

Often for large projects you will want to encapsulate this command in a batch or shell script so that you don’t need to type the command each time.

For a Windows machine, a batch script placed in the content project (such that this file resides next to the “assets” and “compiled” directories), might look like:

For Linux, the shell script might look like:

Remote compilation

Compilation of effects (shaders) requires a Windows machine because the process requires access to the DirectX APIs to parse the HLSL syntax. However, it is possible for the compilation to be performed remotely; that is, the compilation is invoked on a Linux machine (either during the game or part of the asset tool) and the request is routed over the network to a Windows machine where the compilation actually occurs. The resulting shader code is then returned back over the network to the original machine.

For non-Windows machines, the default effect compiler searches the local network for a Windows machine running the remote compiler. On a Windows machine, you can start the remote compiler with the following command:

ProtogameAssetTool.exe -m remote

This tool requires port 4321 and 8080 to be open in the Windows firewall; when it starts for the first time it will attempt to do this and you may see UAC dialogs appear as it requests administrator permission.

As long as there is at least one Windows machine running this tool on the same subnet as the Linux or Mac OS X machines, they will transparently compile effects correctly as if it was being done locally.

The remote compiler requires both the latest DirectX and the Visual C++ 2010 Redistributable installed on the machine that is running it in order to invoke the shader compilation library.

API Documentation

IAsset

interface IAsset

The interface for all assets.

When you implement a new asset type, you need to implement this interface.

readonly bool CompiledOnly

Gets a value indicating whether the asset only contains compiled information.

Value:Whether the asset only contains compiled information.

readonly string Name

Gets the name of the asset.

Value:The name of the asset.

readonly bool SourceOnly

Gets a value indicating whether the asset only contains source information.

Value:Whether the asset only contains source information.

Protogame.T Resolve<T>()

Attempt to resolve this asset to the specified type.

Type Parameters:  

• T – The target type of the asset.

Returns:

The current asset as a :T.

LevelDataFormat

enum LevelDataFormat : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines the format of level data in level assets.

LevelDataFormat Unknown

The level data is in an unknown format.

LevelDataFormat OgmoEditor

The level data is exported from Ogmo Editor.

LevelDataFormat ATF

The level data is exported from an ATF-based level editor.

ModelVertex

struct ModelVertex : System.ValueType

Represents a model vertex with all available data from the model.

Models may store different data in different areas depending on what shader is intended to be used with the model. For example, some models might specify vertex colors, and others might use textures and bump maps.

System.Nullable<Vector3> Position

The 3D position in space of this vertex, if specified.

System.Nullable<Vector3> Normal

The normal of the vertex, if specified.

System.Nullable<Vector3> Tangent

The tangent of the vertex, if specified.

System.Nullable<Vector3> BiTangent

The bitangent of the vertex, if specified.

Microsoft.Xna.Framework.Color[] Colors

The color channels associated with the vertex. A vertex can have zero or more color channels.

Microsoft.Xna.Framework.Vector2[] TexCoordsUV

The 2D texture coordinates associated with the vertex. These texture coordinates are often refered to as UV-coordinates. A vertex can have zero or more texture coordinate channels.

Microsoft.Xna.Framework.Vector3[] TexCoordsUVW

The 3D texture coordinates associated with the vertex. These texture coordinates are often refered to as UVW-coordinates. Often you won’t use these; they’re only used if the model is being rendered using a 3D texture or cube, or if you’re storing non-texture data in these channels. A vertex can have zero or more texture coordinate channels.

System.Nullable<Byte4> BoneIndices

The indicies of the bones associated with this vertex. This data is calculated by the model importer based on the bones configured in the model. If there are no bones in the model, or this vertex isn’t affected by bones, this value is null.

System.Nullable<Vector4> BoneWeights

The weights of the bones associated with this vertex. This data is calculated by the model importer based on the bones configured in the model. If there are no bones in the model, or this vertex isn’t affected by bones, this value is null.

string ToString()

Provides a very basic representation of the vertex (just the position information).

Returns:A string representation of the model vertex.

ModelVertex Transform(Matrix matrix)

Transforms the current model vertex by the matrix.

Parameters:

• matrix (Microsoft.Xna.Framework.Matrix) –

Returns:

ProtogameAssetModule

class ProtogameAssetModule : System.Object, IProtoinjectModule

The asset management module, which provides functionality for loading, saving, compiling and using game assets. Loading this module is recommended, but you can omit it if you want to use your own asset management system.

public void Load(IKernel kernel)

Parameters:

• kernel (Protoinject.IKernel) –

public void LoadRawAssetStrategies(IKernel kernel)

Parameters:

• kernel (Protoinject.IKernel) –

TargetPlatform

enum TargetPlatform : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Represents a platform that Protogame can either execute on, or output asset content for.

TargetPlatform Windows

The Windows desktop. This represents running on the Windows desktop using the Win32 API (not Metro).

TargetPlatform Xbox360

XBox 360. This platform is only supported by the original XNA toolkit, and Protogame can not run on it.

TargetPlatform WindowsPhone

Windows Phone 7. This platform is no longer recognised by MonoGame; Protogame still includes this declaration for backwards compatible as this enumeration is serialized as part of assets.

TargetPlatform iOS

Apple iOS devices (including iPhone and iPad).

TargetPlatform Android

Android devices (including phones and tablets).

TargetPlatform Linux

The Linux desktop.

TargetPlatform MacOSX

The Mac OS X desktop.

TargetPlatform WindowsStoreApp

Windows Store applications. This represents running under the new Metro API offered by Windows 8 and later.

TargetPlatform NativeClient

Google NativeClient. This platform is not supported by MonoGame, and as such, Protogame can not run on it.

TargetPlatform Ouya

The OUYA console, which is a superset of the Android functionality.

TargetPlatform PlayStationMobile

PlayStation Mobile. This platform has since been deprecated by Sony.

TargetPlatform WindowsPhone8

Windows Phone 8.

TargetPlatform RaspberryPi

Raspberry Pi. This platform is not supported by MonoGame, and as such, Protogame can not run on it.

TargetPlatform Web

A web application, where the C# code has been converted to Javascript with JSIL. This platform is not yet supported by MonoGame, and as such, Protogame can not run on it.

TargetPlatformUtility

class TargetPlatformUtility : System.Object

A static utility class which returns the platform that

code is currently executing under.

This method allows you to access platform information at runtime. To change what code is built at compile-time based on the platform, use one of the following constants:

• PLATFORM_ANDROID
• PLATFORM_IOS
• PLATFORM_LINUX
• PLATFORM_MACOS
• PLATFORM_OUYA
• PLATFORM_PSMOBILE
• PLATFORM_WINDOWS
• PLATFORM_WINDOWS8
• PLATFORM_WINDOWSGL
• PLATFORM_WINDOWSPHONE
• PLATFORM_WEB

You can use these constants with the #if construct in C#. For example:

public void MyMethod()
{
    #if PLATFORM_WINDOWS
    SomeWindowsSpecificCall()
    #elif PLATFORM_LINUX
    SomeLinuxSpecificCall()
    #endif
}

public TargetPlatform GetExecutingPlatform()

Returns the platform that the game is currently executing on.

Returns:The T:Protogame.TargetPlatform value representing the platform that the game is currently executing on.

TextureAsset

class TextureAsset : System.MarshalByRefObject, IAsset, Protogame.INativeAsset

A texture asset.

This represents a texture, stored in a Protogame asset.

readonly bool CompiledOnly

Gets a value indicating whether the asset only contains compiled information.

Value:Whether the asset only contains compiled information.

readonly string Name

Gets the name of the asset.

Value:The name of the asset.

Protogame.PlatformData PlatformData

Gets or sets the platform-specific data associated with this asset.

Value:The platform-specific data for this asset.

System.Byte[] RawData

Gets or sets the raw texture data. This is the source information used to compile the asset.

Value:The raw texture data.

readonly bool SourceOnly

Gets a value indicating whether the asset only contains source information.

Value:Whether the asset only contains source information.

readonly bool SourcedFromRaw

Gets a value indicating whether or not this asset was sourced from a raw file (such as a PNG image).

Value:The sourced from raw.

readonly Texture2D Texture

Gets the runtime, MonoGame texture.

Value:The MonoGame texture.

public void ReadyOnGameThread()

Reloads the texture from the associated compiled data. After compilation of the texture asset, this reloads the MonoGame representation of the texture so that the Texture property correctly represents a texture based on the compiled data.

public Protogame.T Resolve<T>()

Attempt to resolve this asset to the specified type.

Type Parameters:  

• T – The target type of the asset.

Returns:

The current asset as a :T.

UserInterfaceFormat

enum UserInterfaceFormat : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines the format of user interface schema.

UserInterfaceFormat Unknown

The user interface is in an unknown format.

UserInterfaceFormat XmlVersion2

The user interface is in XML Version 2 format.

Audio

This section of the documention details the audio APIs provided by Protogame.

IAudioHandle

interface IAudioHandle

An interface which represents an instance of an audio asset.

float Volume

The volume of the audio instance.

readonly bool IsPlaying

Whether the audio instance is still playing. When this is false, the audio instance has finished playing.

void Loop()

Plays this audio instance in a loop.

void Pause()

Pauses playback of this audio instance.

void Play()

Starts playing or resumes this audio instance once (not looped).

void Stop(bool immediate)

Stops playback of this audio instance, resetting the playback position to the start of the audio instance.

Parameters:

• immediate (bool) – Wehether to stop the sound immediately.

IAudioUtilities

interface IAudioUtilities

The AudioUtilities interface.

IAudioHandle GetHandle(Protogame.IAssetReference<AudioAsset> asset)

Obtains an audio handle instance for an audio asset. This instance can then be played, looped or stopped through the T:Protogame.IAudioHandle interface.

Parameters:

• asset (Protogame.IAssetReference<AudioAsset>) – The audio asset to obtain an instance handle for.

Returns:

The T:Protogame.IAudioHandle instance handle.

IAudioHandle Loop(Protogame.IAssetReference<AudioAsset> asset)

Obtains an audio handle instance for an audio asset and starts playing it looped. This instance can then be controlled through the T:Protogame.IAudioHandle interface.

Parameters:

• asset (Protogame.IAssetReference<AudioAsset>) – The audio asset to obtain an instance handle for.

Returns:

The T:Protogame.IAudioHandle instance handle.

IAudioHandle Play(Protogame.IAssetReference<AudioAsset> asset)

Obtains an audio handle instance for an audio asset and plays it once. This instance can then be controlled through the T:Protogame.IAudioHandle interface.

Parameters:

• asset (Protogame.IAssetReference<AudioAsset>) – The audio asset to obtain an instance handle for.

Returns:

The T:Protogame.IAudioHandle instance handle.

Graphics

In order to facilitate rendering to the screen, Protogame makes use of a render pipeline, in which multiple render passes are chained together to produce the final result.

Render pipeline overview

Protogame uses a render pipeline to allow multiple render passes to build the final result that is rendered to the screen. This allows post-processing effects to be easily applied to your game.

The Protogame render pipeline is broken up into two stages; the standard render stage and the post-processing render stage.

Each render stage consists of fixed render passes and transient render passes.

Fixed render passes are added to the pipeline during game startup CoreGame<TInitialWorld>.ConfigureRenderPipeline, and added or removed from the pipeline at runtime with IRenderPipeline.AddFixedRenderPass and IRenderPipeline.RemoveFixedRenderPass respectively.

Transient render passes are appended to the current frame of the render pipeline with IRenderPipeline.AppendTransientRenderPass. Transient render passes are only used for the current frame, and do not occur on any future frames unless you call IRenderPipeline.AppendTransientRenderPass again.

A visual graph of the render pipeline demonstrates the method calls that are made during each stage, how render pipelines are added, and what render targets are used when rendering is performed in each pass:

Standard render stage

During the standard render stage, all render passes are directed at the same render target, and are applied in order.

Types of standard render passes are:

• Protogame.I2DDirectRenderPass
• Protogame.I2DBatchedRenderPass
• Protogame.I3DRenderPass

These render passes are used for general game rendering. For example, you can render your game in a Protogame.I3DRenderPass, and your UI in a Protogame.I2DDirectRenderPass or Protogame.I2DBatchedRenderPass.

Post-processing render stage

During the post-processing render stage, each render pass is provided a render target representing the result of the previous render stage.

Types of post-processing render passes are:

• Protogame.IInvertPostProcessingRenderPass
• Protogame.IBlurPostProcessingRenderPass
• Protogame.ICaptureCopyPostProcessingRenderPass
• Protogame.ICaptureInlinePostProcessingRenderPass
• Protogame.ICustomPostProcessingRenderPass

These render passes are for applying additional effects after your game has been rendered.

Creating render passes

Render passes can be created by injecting the Protogame.IGraphicsFactory service, and using the methods available.

Adding fixed render passes

Fixed render passes are the main render passes that apply every frame, for the entire time that your game is running.

Fixed render passes are primarily set up when deriving from CoreGame<TInitialWorld>.ConfigureRenderPipeline in your own game class. You can add and remove fixed render passes at runtime using the methods on Protogame.IRenderContext.

Configuring at game start

You can configure the fixed render passes used in game at game start, by calling IRenderPipeline.AddFixedRenderPass:

public class AddingFixedRenderPassExampleGame : CoreGame<RenderPipelineWorld>
{
    public AddingFixedRenderPassExampleGame(IKernel kernel) : base(kernel)
    {
    }

    protected override void ConfigureRenderPipeline(IRenderPipeline pipeline, IKernel kernel)
    {
        var factory = kernel.Get<IGraphicsFactory>();
        
        // Add a 3D render pass in which we render the main game world.
        pipeline.AddFixedRenderPass(factory.Create3DRenderPass());
        
        // Add a 2D batched render pass in which we render the UI.
        pipeline.AddFixedRenderPass(factory.Create2DBatchedRenderPass());
    }
}

Modifying at runtime

You can add and remove fixed render passes at runtime, by calling IRenderContext.AddFixedRenderPass and IRenderContext.RemoveFixedRenderPass:

public class FixedRenderPassEntity : Entity
{
    private readonly IRenderPass _renderPass;
    
    private bool _someOnceOffField;
    
    public FixedRenderPassEntity(IGraphicsFactory graphicsFactory)
    {
        _renderPass = graphicsFactory.Create3DRenderPass();
        _someOnceOffField = true;
    }

    public override void Render(IGameContext gameContext, IRenderContext renderContext)
    {
        if (renderContext.IsFirstRenderPass() && _someOnceOffField)
        {
            // You only want to call this method once, since fixed render passes are
            // permanently in the pipeline until RemoveFixedRenderPass is called.  If
            // this block of code were allowed to execute every frame, the render
            // pipeline would become infinitely long.
            renderContext.AddFixedRenderPass(_renderPass);
            _someOnceOffField = false;
        }
    }
}

Adding transient render passes

Transient render passes are additional render passes that apply only on the frame that they are appended.

Transient render passes are primarily used for applying temporary effects to the screen, such as applying a post-processing effect when the player dies.

Appending at runtime

You can append transient render passes to the game at runtime using the IRenderContext.AppendTransientRenderPass method:

public class TransientRenderPassEntity : Entity
{
    private readonly IRenderPass _renderPass;
    
    public TransientRenderPassEntity(IGraphicsFactory graphicsFactory)
    {
        _renderPass = graphicsFactory.CreateBlurPostProcessingRenderPass();
    }

    public override void Render(IGameContext gameContext, IRenderContext renderContext)
    {
        if (renderContext.IsFirstRenderPass())
        {
            renderContext.AppendTransientRenderPass(_renderPass);
        }
    }
}

API Documentation

I2DBatchedLoadingScreenRenderPass

interface I2DBatchedLoadingScreenRenderPass : IRenderPass, Protogame.IRenderPassWithViewport

A render pass in which graphics rendering is configured for an orthographic view. When this render pass is active, the X and Y positions of entities map directly to the X and Y positions of the game window, with (0, 0) being located in the top-left.

During this render pass, all texture render calls are batched together with a T:Microsoft.Xna.Framework.Graphics.SpriteBatch, and flushed at the end of the render pass.

This is a seperate render pass to T:Protogame.I2DBatchedRenderPass to allow optimal rendering of basic loading screens.

SpriteSortMode TextureSortMode

Gets or sets the sorting mode for textures during batch rendering.

This value is used as the sorting mode for the underlying T:Microsoft.Xna.Framework.Graphics.SpriteBatch.

Value:The sorting mode to use when rendering textures.

I2DBatchedRenderPass

interface I2DBatchedRenderPass : IRenderPass, Protogame.IRenderPassWithViewport

A render pass in which graphics rendering is configured for an orthographic view. When this render pass is active, the X and Y positions of entities map directly to the X and Y positions of the game window, with (0, 0) being located in the top-left.

During this render pass, all texture render calls are batched together with a T:Microsoft.Xna.Framework.Graphics.SpriteBatch, and flushed at the end of the render pass.

SpriteSortMode TextureSortMode

Gets or sets the sorting mode for textures during batch rendering.

This value is used as the sorting mode for the underlying T:Microsoft.Xna.Framework.Graphics.SpriteBatch.

Value:The sorting mode to use when rendering textures.

I2DDirectRenderPass

interface I2DDirectRenderPass : IRenderPass, Protogame.IRenderPassWithViewport

A render pass in which graphics rendering is configured for an orthographic view. When this render pass is active, the X and Y positions of entities map directly to the X and Y positions of the game window, with (0, 0) being located in the top-left.

During this render pass, rendering operations are performed immediately on the rendering target. To batch multiple texture render calls, use an T:Protogame.I2DBatchedRenderPass instead or in addition to this render pass.

I3DBatchedRenderPass

interface I3DBatchedRenderPass : I3DRenderPass, IRenderPass

Indicates a 3D render pass in which calls to render data should go through the T:Protogame.IRenderBatcher service for optimal rendering.

I3DDeferredRenderPass

interface I3DDeferredRenderPass : I3DBatchedRenderPass, I3DRenderPass, IRenderPass, Protogame.IRenderPassWithViewport

A 3D render pass that uses forward rendering.

bool DebugGBuffer

If set to true, renders the scene as four quadrants with the internal render target state. This can be used to diagnose rendering issues related to colors, normals, depth map or lighting shaders.

bool ClearDepthBuffer

Clear the depth buffer before this render pass starts rendering. This allows you to alpha blend a 3D deferred render pass on top of a 2D render pass, without the 2D render pass interfering with the rendering of 3D objects.

bool ClearTarget

Clear the target before this render pass starts rendering. If your scene doesn’t fully cover the scene this should be turned on (unless you want what was previously rendered to remain on screen). This is on by default.

BlendState GBufferBlendState

The blend state to use when rendering the final G-buffer onto the backbuffer (or current render target). By default this is opaque, which is probably what you want if the deferred rendering pass is the first in the pipeline. However if you’re rendering 2D content underneath the 3D content, you should set this to something like F:Microsoft.Xna.Framework.Graphics.BlendState.AlphaBlend.

I3DForwardRenderPass

interface I3DForwardRenderPass : I3DBatchedRenderPass, I3DRenderPass, IRenderPass, Protogame.IRenderPassWithViewport

A 3D render pass that uses forward rendering.

I3DRenderPass

interface I3DRenderPass : IRenderPass

The base render pass interface for 3D render passes.

IBlurPostProcessingRenderPass

interface IBlurPostProcessingRenderPass : IRenderPass, Protogame.IRenderPassWithViewport

A post-processing render pass which applies a guassian blur to the screen.

int Iterations

The number of iterations of blur to apply.

ICanvasRenderPass

interface ICanvasRenderPass : IRenderPass, Protogame.IRenderPassWithViewport

A render pass in which graphics rendering is configured for an orthographic view, and canvas entities will automatically render their canvases. When this render pass is active, the X and Y positions of entities map directly to the X and Y positions of the game window, with (0, 0) being located in the top-left.

During this render pass, all texture render calls are batched together with a T:Microsoft.Xna.Framework.Graphics.SpriteBatch, and flushed at the end of the render pass.

This render pass is identical to T:Protogame.I2DBatchedRenderPass, except it is given an explicit interface so that T:Protogame.CanvasEntity knows when to render.

System.Nullable<Viewport> Viewport

Gets or sets the viewport used in this rendering pass.

By configuring different viewports on multiple render passes, you can easily configure split-screen games, where different viewports are used for different players.

Value:The viewport used for rendering.

SpriteSortMode TextureSortMode

Gets or sets the sorting mode for textures during batch rendering.

This value is used as the sorting mode for the underlying T:Microsoft.Xna.Framework.Graphics.SpriteBatch.

Value:The sorting mode to use when rendering textures.

ICaptureCopyPostProcessingRenderPass

interface ICaptureCopyPostProcessingRenderPass : IRenderPass

A post-processing render pass which captures the current state of the render pipeline as a separate render target. This is more expensive than T:Protogame.ICaptureInlinePostProcessingRenderPass, but allows you to access the result at any time between the end of this render pass, and the begin of this render pass in the next frame.

readonly RenderTarget2D CapturedRenderTarget

The captured render target. This property is null before the first frame is rendered.

ICaptureInlinePostProcessingRenderPass

interface ICaptureInlinePostProcessingRenderPass : IRenderPass

A post-processing render pass which captures the current state of the render pipeline as a separate render target. This is cheaper than T:Protogame.ICaptureCopyPostProcessingRenderPass, but you can only access the render target state in the action callback set on the render pass. Modifying the render target, e.g. by performing any rendering at all, will modify the result of the render pipeline.

System.Action<RenderTarget2D> RenderPipelineStateAvailable

A callback that is issued when the render pipeline reaches this render pass. This callback makes the current source render target available for capture.

ICustomPostProcessingRenderPass

interface ICustomPostProcessingRenderPass : IRenderPass

A post-processing render pass for a custom shader. You can create this shader via T:Protogame.IGraphicsFactory if you don’t want to strongly type your shader.

readonly Protogame.IAssetReference<EffectAsset> Effect

void SetValue(string name, bool value)

Sets the custom shader parameter to the specified boolean.

Parameters:

• name (string) – The name of the parameter to set.
• value (bool) – The new boolean value.

void SetValue(string name, int value)

Sets the custom shader parameter to the specified integer.

Parameters:

• name (string) – The name of the parameter to set.
• value (int) – The new integer value.

void SetValue(string name, Matrix value)

Sets the custom shader parameter to the specified matrix.

Parameters:

• name (string) – The name of the parameter to set.
• value (Microsoft.Xna.Framework.Matrix) – The new matrix.

void SetValue(string name, Microsoft.Xna.Framework.Matrix[] value)

Sets the custom shader parameter to the specified array of matrixes.

Parameters:

• name (string) – The name of the parameter to set.
• value (Microsoft.Xna.Framework.Matrix[]) – The new array of matrixes.

void SetValue(string name, Quaternion value)

Sets the custom shader parameter to the specified quaternion.

Parameters:

• name (string) – The name of the parameter to set.
• value (Microsoft.Xna.Framework.Quaternion) – The new quaternion.

void SetValue(string name, float value)

Sets the custom shader parameter to the specified floating point value.

Parameters:

• name (string) – The name of the parameter to set.
• value (float) – The new floating point value.

void SetValue(string name, System.Single[] value)

Sets the custom shader parameter to the specified array of floating point values.

Parameters:

• name (string) – The name of the parameter to set.
• value (System.Single[]) – The new array of floating point values.

void SetValue(string name, Texture value)

Sets the custom shader parameter to the specified texture.

Parameters:

• name (string) – The name of the parameter to set.
• value (Microsoft.Xna.Framework.Graphics.Texture) – The new texture.

void SetValue(string name, Vector2 value)

Sets the custom shader parameter to the specified 2-dimensional vector.

Parameters:

• name (string) – The name of the parameter to set.
• value (Microsoft.Xna.Framework.Vector2) – The new 2-dimensional vector.

void SetValue(string name, Microsoft.Xna.Framework.Vector2[] value)

Sets the custom shader parameter to the specified array of 2-dimensional vectors.

Parameters:

• name (string) – The name of the parameter to set.
• value (Microsoft.Xna.Framework.Vector2[]) – The new array of 2-dimensional vectors.

void SetValue(string name, Vector3 value)

Sets the custom shader parameter to the specified 3-dimensional vector.

Parameters:

• name (string) – The name of the parameter to set.
• value (Microsoft.Xna.Framework.Vector3) – The new 3-dimensional vector.

void SetValue(string name, Microsoft.Xna.Framework.Vector3[] value)

Sets the custom shader parameter to the specified array of 3-dimensional vectors.

Parameters:

• name (string) – The name of the parameter to set.
• value (Microsoft.Xna.Framework.Vector3[]) – The new array of 3-dimensional vectors.

void SetValue(string name, Vector4 value)

Sets the custom shader parameter to the specified 4-dimensional vector.

Parameters:

• name (string) – The name of the parameter to set.
• value (Microsoft.Xna.Framework.Vector4) – The new 4-dimensional vector.

void SetValue(string name, Microsoft.Xna.Framework.Vector4[] value)

Sets the custom shader parameter to the specified array of 4-dimensional vectors.

Parameters:

• name (string) – The name of the parameter to set.
• value (Microsoft.Xna.Framework.Vector4[]) – The new array of 4-dimensional vectors.

IGraphicsBlit

interface IGraphicsBlit

Provides basic graphics blitting functionality.

This services provides a M:Protogame.IGraphicsBlit.Blit(Protogame.IRenderContext,Microsoft.Xna.Framework.Graphics.Texture2D,Microsoft.Xna.Framework.Graphics.RenderTarget2D,Protogame.IEffect,Protogame.IEffectParameterSet,Microsoft.Xna.Framework.Graphics.BlendState,System.Nullable{Microsoft.Xna.Framework.Vector2},System.Nullable{Microsoft.Xna.Framework.Vector2}) method, which can be used to copy the contents of one render target to another render target (or the backbuffer), optionally using a different shader.

void Blit(IRenderContext renderContext, Texture2D source, RenderTarget2D destination, Protogame.IEffect shader, Protogame.IEffectParameterSet effectParameterSet, BlendState blendState, System.Nullable<Vector2> offset, System.Nullable<Vector2> size)

Blits a render target onto another render target (or the backbuffer), using either the default blit shader, or a specific effect for post-processing render passes.

Parameters:

• renderContext (Protogame.IRenderContext) – The current render context.
• source (Microsoft.Xna.Framework.Graphics.Texture2D) – The source render target. If null, does not load a source texture.
• destination (Microsoft.Xna.Framework.Graphics.RenderTarget2D) – The destination render target, or the current render target if null.
• shader (Protogame.IEffect) – The effect shader to use, or the default blit shader if null.
• effectParameterSet (Protogame.IEffectParameterSet) – The effect parameters to use, or the default parameter set if null.
• blendState (Microsoft.Xna.Framework.Graphics.BlendState) – The blend state to use, or opaque blend mode if null.
• offset (System.Nullable<Vector2>) – The top left position on the target. (0, 0) is top left, (1, 1) is bottom right.
• size (System.Nullable<Vector2>) – The size of the render onto the target. (1, 1) is the full size of the target.

void BlitMRT(IRenderContext renderContext, Texture2D source, Microsoft.Xna.Framework.Graphics.RenderTarget2D[] destinations, Protogame.IEffect shader, Protogame.IEffectParameterSet effectParameterSet, BlendState blendState, System.Nullable<Vector2> offset, System.Nullable<Vector2> size)

Blits a render target to multiple other render targets, using a specific effect that writes to multiple render targets.

Parameters:

• renderContext (Protogame.IRenderContext) – The current render context.
• source (Microsoft.Xna.Framework.Graphics.Texture2D) – The source render target. If null, does not load a source texture.
• destinations (Microsoft.Xna.Framework.Graphics.RenderTarget2D[]) – The destination render targets.
• shader (Protogame.IEffect) – The effect shader to use.
• effectParameterSet (Protogame.IEffectParameterSet) – The effect parameters to use.
• blendState (Microsoft.Xna.Framework.Graphics.BlendState) – The blend state to use, or opaque blend mode if null.
• offset (System.Nullable<Vector2>) – The top left position on the target. (0, 0) is top left, (1, 1) is bottom right.
• size (System.Nullable<Vector2>) – The size of the render onto the target. (1, 1) is the full size of the target.

IGraphicsFactory

interface IGraphicsFactory : IGenerateFactory

The factory interface which is used to create render passes before they are added to the render pipeline.

Use these methods to construct render passes with the appropriate settings, and pass the resulting value into M:Protogame.IRenderPipeline.AddFixedRenderPass(Protogame.IRenderPass) or M:Protogame.IRenderPipeline.AppendTransientRenderPass(Protogame.IRenderPass).

I2DDirectRenderPass Create2DDirectRenderPass()

Creates a render pass in which graphics rendering is configured for an orthographic view. When this render pass is active, the X and Y positions of entities map directly to the X and Y positions of the game window, with (0, 0) being located in the top-left.

During this render pass, rendering operations are performed immediately on the rendering target. To batch multiple texture render calls, use an T:Protogame.I2DBatchedRenderPass instead or in addition to this render pass.

Returns:A 2D render pass where rendering is performed directly.

I2DBatchedRenderPass Create2DBatchedRenderPass()

Creates a render pass in which graphics rendering is configured for an orthographic view. When this render pass is active, the X and Y positions of entities map directly to the X and Y positions of the game window, with (0, 0) being located in the top-left.

During this render pass, all texture render calls are batched together with a T:Microsoft.Xna.Framework.Graphics.SpriteBatch, and flushed at the end of the render pass.

Returns:A 2D render pass where rendering is batched together.

I2DBatchedLoadingScreenRenderPass Create2DBatchedLoadingScreenRenderPass()

Creates a render pass in which graphics rendering is configured for an orthographic view. When this render pass is active, the X and Y positions of entities map directly to the X and Y positions of the game window, with (0, 0) being located in the top-left.

During this render pass, all texture render calls are batched together with a T:Microsoft.Xna.Framework.Graphics.SpriteBatch, and flushed at the end of the render pass.

This is a seperate render pass to T:Protogame.I2DBatchedRenderPass to allow optimal rendering of basic loading screens.

Returns:A 2D render pass where rendering is batched together.

ICanvasRenderPass CreateCanvasRenderPass()

Creates a render pass in which graphics rendering is configured for an orthographic view, and canvas entities will automatically render their canvases. When this render pass is active, the X and Y positions of entities map directly to the X and Y positions of the game window, with (0, 0) being located in the top-left.

During this render pass, all texture render calls are batched together with a T:Microsoft.Xna.Framework.Graphics.SpriteBatch, and flushed at the end of the render pass.

This render pass is identical to T:Protogame.I2DBatchedRenderPass, except it is given an explicit interface so that T:Protogame.CanvasEntity knows when to render.

Returns:A 2D render pass where canvases are rendered.

I3DForwardRenderPass Create3DRenderPass()

I3DForwardRenderPass Create3DForwardRenderPass()

Creates a render pass in which forward rendering is used.

Returns:A 3D render pass.

I3DDeferredRenderPass Create3DDeferredRenderPass()

Creates a render pass in which deferred rendering is used.

Returns:A 3D render pass.

Protogame.IDebugRenderPass CreateDebugRenderPass()

Creates a render pass in which calls to T:Protogame.IDebugRenderer and the state of physics objects are rendered to the screen.

Returns:A debug render pass.

Protogame.IConsoleRenderPass CreateConsoleRenderPass()

Creates a render pass which handles an in-game console. You need to include a console render pass if you want custom commands with T:Protogame.ICommand to work.

Returns:A console render pass.

IInvertPostProcessingRenderPass CreateInvertPostProcessingRenderPass()

Creates a post-processing render pass which inverts all of the colors on the screen.

Returns:A color inversion post-processing render pass.

IBlurPostProcessingRenderPass CreateBlurPostProcessingRenderPass()

Creates a post-processing render pass which applies a guassian blur filter to the screen.

Returns:A guassian blur post-processing render pass.

ICustomPostProcessingRenderPass CreateCustomPostProcessingRenderPass(string effectAssetName)

Creates a post-processing render pass that uses a custom effect (shader).

This method is a quick way of creating new post-processing render passes based on custom shaders, without implementing T:Protogame.IRenderPass. However, by using T:Protogame.ICustomPostProcessingRenderPass, you don’t obtain any strongly typed validation of shader usage, so it’s preferable to implement a render pass for each new post-processing render pass you want to create.

Parameters:

• effectAssetName (string) – The name of the effect asset to use.

Returns:

A custom post-processing render pass using the shader you specified.

ICustomPostProcessingRenderPass CreateCustomPostProcessingRenderPass(Protogame.EffectAsset effectAsset)

Creates a post-processing render pass that uses a custom effect (shader).

This method is a quick way of creating new post-processing render passes based on custom shaders, without implementing T:Protogame.IRenderPass. However, by using T:Protogame.ICustomPostProcessingRenderPass, you don’t obtain any strongly typed validation of shader usage, so it’s preferable to implement a render pass for each new post-processing render pass you want to create.

Parameters:

• effectAsset (Protogame.EffectAsset) – The effect asset to use.

Returns:

A custom post-processing render pass using the shader you specified.

ICustomPostProcessingRenderPass CreateCustomPostProcessingRenderPass(Effect effect)

Creates a post-processing render pass that uses a custom effect (shader).

This method is a quick way of creating new post-processing render passes based on custom shaders, without implementing T:Protogame.IRenderPass. However, by using T:Protogame.ICustomPostProcessingRenderPass, you don’t obtain any strongly typed validation of shader usage, so it’s preferable to implement a render pass for each new post-processing render pass you want to create.

Parameters:

• effect (Microsoft.Xna.Framework.Graphics.Effect) – The effect to use.

Returns:

A custom post-processing render pass using the shader you specified.

ICaptureCopyPostProcessingRenderPass CreateCaptureCopyPostProcessingRenderPass()

Creates a post-processing render pass which captures the current state of the render pipeline as a separate render target. This is more expensive than T:Protogame.ICaptureInlinePostProcessingRenderPass, but allows you to access the result at any time between the end of this render pass, and the begin of this render pass in the next frame.

ICaptureInlinePostProcessingRenderPass CreateCaptureInlinePostProcessingRenderPass()

Creates a post-processing render pass which captures the current state of the render pipeline as a separate render target. This is cheaper than T:Protogame.ICaptureCopyPostProcessingRenderPass, but you can only access the render target state in the action callback set on the render pass. Modifying the render target, e.g. by performing any rendering at all, will modify the result of the render pipeline.

IInvertPostProcessingRenderPass

interface IInvertPostProcessingRenderPass : IRenderPass

A post-processing render pass which inverts all colours on the screen.

IRenderPass

interface IRenderPass

A render pass represents an evaluation of all entities within the render pipeline, or a post-processing render pass which applies to the rendered image of the game.

readonly bool IsPostProcessingPass

Gets a value indicating whether this render pass applies a post-processing effect.

A standard (non-post-processing) render pass calls a Render method for all entities in the world, as well as RenderBelow and RenderAbove on the current world.

If there are no post-processing render passes configured, then all standard render passes perform draw calls directly to the backbuffer.

If there are post-processing render passes configured, then all standard render passes perform draw calls to an internal render target, which is used as the texture when rendering the screen triangles for the first post-processing pass.

The result of each post-processing pass is directed to a render target, which is used as the texture for the next post-processing pass. The exception is that the last post-processing render pass will draw to the back-buffer instead of an internal render target.

When render passes are added or appended to the T:Protogame.IRenderContext, the engine ensures that all post-processing render passes occur after all standard render passes.

Value:true if this render pass is a post-processing render pass; otherwise, false.

readonly bool SkipWorldRenderBelow

Gets a value indicating whether the call to M:Protogame.IWorld.RenderBelow(Protogame.IGameContext,Protogame.IRenderContext) should be skipped in this render pipeline. This value is ignored for post-processing render passes, which never call M:Protogame.IWorld.RenderBelow(Protogame.IGameContext,Protogame.IRenderContext).

readonly bool SkipEntityRender

Gets a value indicating whether the call to M:Protogame.IEntity.Render(Protogame.IGameContext,Protogame.IRenderContext) should be skipped in this render pipeline. This value is ignored for post-processing render passes, which never call M:Protogame.IEntity.Render(Protogame.IGameContext,Protogame.IRenderContext).

readonly bool SkipWorldRenderAbove

Gets a value indicating whether the call to M:Protogame.IWorld.RenderAbove(Protogame.IGameContext,Protogame.IRenderContext) should be skipped in this render pipeline. This value is ignored for post-processing render passes, which never call M:Protogame.IWorld.RenderAbove(Protogame.IGameContext,Protogame.IRenderContext).

readonly bool SkipEngineHookRender

Gets a value indicating whether the call to M:Protogame.IEngineHook.Render(Protogame.IGameContext,Protogame.IRenderContext) should be skipped in this render pipeline. This value is ignored for post-processing render passes, which never call M:Protogame.IEngineHook.Render(Protogame.IGameContext,Protogame.IRenderContext).

readonly string EffectTechniqueName

Sets the technique name that should be used when effects are used within this render pass. Effects can have multiple techniques, each with different names. When effects are pushed onto the render context, the technique that matches the name requested by the render pass is the one selected for the effect. This allows effects to be written that support both forward and deferred rendering, which supply different techniques for each.

string Name

An optional name that can be set against a render pass. If you have multiple render passes in your game of the same type, you can set a name against each of the render passes and distinguish where in the render pipeline you are currently rendering by checking the name. This is useful, for example, if you want to render a 2D sprite below a 3D world, and then layer 2D text on top (using two 2D batched render passes).

void BeginRenderPass(IGameContext gameContext, IRenderContext renderContext, IRenderPass previousPass, RenderTarget2D postProcessingSource)

Begins the render pass.

During this method, the render pass implementation will configure the T:Microsoft.Xna.Framework.Graphics.GraphicsDevice (which is available via T:Protogame.IRenderContext) so that the correct shader and graphics settings are configured. Before this method is called, the game engine will set up any render targets that are required for the render pipeline to operate.

Parameters:

• gameContext (Protogame.IGameContext) – The current game context.
• renderContext (Protogame.IRenderContext) – The current render context.
• previousPass (Protogame.IRenderPass) – The previous render pass, or null if this is the first pass in the pipeline.
• postProcessingSource (Microsoft.Xna.Framework.Graphics.RenderTarget2D) –

  If this is a post-processing render pass, this argument is set to the source texture that is used as input for the shader. As a general guide, you should pass this texture as the source parameter to the M:Protogame.IGraphicsBlit.Blit(Protogame.IRenderContext,Microsoft.Xna.Framework.Graphics.Texture2D,Microsoft.Xna.Framework.Graphics.RenderTarget2D,Protogame.IEffect,Protogame.IEffectParameterSet,Microsoft.Xna.Framework.Graphics.BlendState,System.Nullable{Microsoft.Xna.Framework.Vector2},System.Nullable{Microsoft.Xna.Framework.Vector2}) if you are using that API.

  If this is a standard render pass, this argument is always null.

void EndRenderPass(IGameContext gameContext, IRenderContext renderContext, IRenderPass nextPass)

Ends the render pass.

During this method, the render pass implementation will perform any remaining operations that need to occur before the next render pass runs. It is not required that a render pass configure the graphics device back to it’s original state; it is expected that each new render pass will configure all of the appropriate settings of the T:Microsoft.Xna.Framework.Graphics.GraphicsDevice when it runs.

Parameters:

• gameContext (Protogame.IGameContext) – The current game context.
• renderContext (Protogame.IRenderContext) – The current render context.
• nextPass (Protogame.IRenderPass) – The next render pass, or null if this is the last pass in the pipeline.

IRenderPipeline

interface IRenderPipeline

The interface for the rendering pipeline.

void Render(IGameContext gameContext, IRenderContext renderContext)

Renders the game using the render pipeline.

Parameters:

• gameContext (Protogame.IGameContext) – The current game context.
• renderContext (Protogame.IRenderContext) – The current render context.

IRenderPass AddFixedRenderPass(IRenderPass renderPass)

Adds the specified render pass to the render pipeline permanently. This render pass will take effect after the start of the next frame.

Parameters:

• renderPass (Protogame.IRenderPass) – The render pass to add.

Returns:

The render pass that was given to this function. This return value is for convenience only, so that you may construct and add a render pass in a single statement, while obtaining a reference to it if you need to modify it’s values or call M:Protogame.IRenderPipeline.RemoveFixedRenderPass(Protogame.IRenderPass) later. The render pass is not modified by this function.

void RemoveFixedRenderPass(IRenderPass renderPass)

Removes the specified render pass from the render pipeline.

Parameters:

• renderPass (Protogame.IRenderPass) – The render pass to remove.

IRenderPass AppendTransientRenderPass(IRenderPass renderPass)

Append the specified render pass to the render pipeline for this frame only. This is method that allows you to temporarily add additional render passes to a frame.

If all standard (non-post-processing) render passes have finished post-processing has begun and this method is given a standard render pass, it will have no effect.

Render passes that were appended can not be removed with M:Protogame.IRenderPipeline.RemoveFixedRenderPass(Protogame.IRenderPass).

Parameters:

• renderPass (Protogame.IRenderPass) – The render pass to add.

Returns:

The render pass that was given to this function. This return value is for convenience only, so that you may construct and add a render pass in a single statement, while obtaining a reference to it if you need to modify it’s value. The render pass is not modified by this function.

IRenderPass GetCurrentRenderPass()

Returns the current render pass. Returns null if the code is not currently executing from within M:Protogame.IRenderPipeline.Render(Protogame.IGameContext,Protogame.IRenderContext).

Returns:The current render pass, or null if the render pipeline isn’t rendering.

bool IsFirstRenderPass()

Returns if the current render pass is the first one in the pipeline.

Returns:Whether the current render pass is the first one in the pipeline.

IRenderTargetBackBufferUtilities

interface IRenderTargetBackBufferUtilities

This services provides utility methods for making render targets match the backbuffer.

RenderTarget2D UpdateRenderTarget(RenderTarget2D renderTarget, IGameContext gameContext)

Given an existing (or null) render target, returns either the existing render target, or disposes the existing render target and creates a new one so that the returned render target matches the backbuffer.

Parameters:

• renderTarget (Microsoft.Xna.Framework.Graphics.RenderTarget2D) – The existing render target, which is either returned or disposed.
• gameContext (Protogame.IGameContext) – The current game context.

Returns:

A render target that matches the backbuffer.

RenderTarget2D UpdateCustomRenderTarget(RenderTarget2D renderTarget, IGameContext gameContext, System.Nullable<SurfaceFormat> surfaceFormat, System.Nullable<DepthFormat> depthFormat, System.Nullable<Int32> multiSampleCount)

Given an existing (or null) render target, returns either the existing render target, or disposes the existing render target and creates a new one so that the returned render target matches the backbuffer size, with a custom surface format and no depth buffer.

Parameters:

• renderTarget (Microsoft.Xna.Framework.Graphics.RenderTarget2D) – The existing render target, which is either returned or disposed.
• gameContext (Protogame.IGameContext) – The current game context.
• surfaceFormat (System.Nullable<SurfaceFormat>) – The surface format to use.
• depthFormat (System.Nullable<DepthFormat>) –
• multiSampleCount (System.Nullable<Int32>) –

Returns:

A render target that matches the backbuffer in size.

bool IsRenderTargetOutOfDate(RenderTarget2D renderTarget, IGameContext gameContext)

Returns whether the specified render target matches the backbuffer.

Parameters:

• renderTarget (Microsoft.Xna.Framework.Graphics.RenderTarget2D) – The render target to check.
• gameContext (Protogame.IGameContext) – The current game context.

Returns:

Whether the specified render target matches the backbuffer.

bool IsCustomRenderTargetOutOfDate(RenderTarget2D renderTarget, IGameContext gameContext, System.Nullable<SurfaceFormat> surfaceFormat, System.Nullable<DepthFormat> depthFormat, System.Nullable<Int32> multiSampleCount)

Returns whether the specified custom render target matches the backbuffer size and specified surface format.

Parameters:

• renderTarget (Microsoft.Xna.Framework.Graphics.RenderTarget2D) – The render target to check.
• gameContext (Protogame.IGameContext) – The current game context.
• surfaceFormat (System.Nullable<SurfaceFormat>) – The surface format to use.
• depthFormat (System.Nullable<DepthFormat>) –
• multiSampleCount (System.Nullable<Int32>) –

Returns:

Whether the specified render target matches the backbuffer size and specified surface format.

Graphics: 2D Rendering

Note

This documentation is a work-in-progress.

The 2D rendering utilities provide common functionality for rendering textures, text and other primitives to the screen.

These utilities are available for all games, and are always bound. You do not need to load a module to access them.

HorizontalAlignment

enum HorizontalAlignment : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Represents horizontal alignment.

HorizontalAlignment Left

The given X value should indicate the left of what is being aligned.

HorizontalAlignment Center

The given X value should indicate the center of what is being aligned.

HorizontalAlignment Right

The given X value should indicate the right of what is being aligned.

I2DRenderUtilities

interface I2DRenderUtilities

The 2DRenderUtilities interface.

Vector2 MeasureText(IRenderContext context, string text, Protogame.IAssetReference<FontAsset> font)

Measures text as if it was rendered with the font asset.

Parameters:

• context (Protogame.IRenderContext) – The rendering context.
• text (string) – The text to render.
• font (Protogame.IAssetReference<FontAsset>) – The font to use for rendering.

Returns:

The T:Microsoft.Xna.Framework.Vector2.

void RenderLine(IRenderContext context, Vector2 start, Vector2 end, Color color, float width)

Renders a 2D line.

Parameters:

• context (Protogame.IRenderContext) – The rendering context.
• start (Microsoft.Xna.Framework.Vector2) – The start of the line.
• end (Microsoft.Xna.Framework.Vector2) – The end of the line.
• color (Microsoft.Xna.Framework.Color) – The color of the line.
• width (float) – The width of the line (defaults to 1).

void RenderRectangle(IRenderContext context, Rectangle rectangle, Color color, bool filled)

Renders a rectangle.

Parameters:

• context (Protogame.IRenderContext) – The rendering context.
• rectangle (Microsoft.Xna.Framework.Rectangle) – The rectangle to render.
• color (Microsoft.Xna.Framework.Color) – The color of the rectangle.
• filled (bool) – If set to true, the rectangle is rendered filled.

void RenderText(IRenderContext context, Vector2 position, string text, Protogame.IAssetReference<FontAsset> font, HorizontalAlignment horizontalAlignment, VerticalAlignment verticalAlignment, System.Nullable<Color> textColor, bool renderShadow, System.Nullable<Color> shadowColor)

Renders text at the specified position.

Parameters:

• context (Protogame.IRenderContext) – The rendering context.
• position (Microsoft.Xna.Framework.Vector2) – The position to render the text.
• text (string) – The text to render.
• font (Protogame.IAssetReference<FontAsset>) – The font to use for rendering.
• horizontalAlignment (Protogame.HorizontalAlignment) – The horizontal alignment of the text (defaults to Left).
• verticalAlignment (Protogame.VerticalAlignment) – The vertical alignment of the text (defaults to Top).
• textColor (System.Nullable<Color>) – The text color (defaults to white).
• renderShadow (bool) – Whether to render a shadow on the text (defaults to true).
• shadowColor (System.Nullable<Color>) – The text shadow’s color (defaults to black).

void RenderTexture(IRenderContext context, Vector2 position, Protogame.IAssetReference<TextureAsset> texture, System.Nullable<Vector2> size, System.Nullable<Color> color, float rotation, System.Nullable<Vector2> rotationAnchor, bool flipHorizontally, bool flipVertically, System.Nullable<Rectangle> sourceArea)

Renders a texture at the specified position.

Parameters:

• context (Protogame.IRenderContext) – The rendering context.
• position (Microsoft.Xna.Framework.Vector2) – The position to render the texture.
• texture (Protogame.IAssetReference<TextureAsset>) – The texture.
• size (System.Nullable<Vector2>) – The size to render the texture as (defaults to the texture size).
• color (System.Nullable<Color>) – The colorization to apply to the texture.
• rotation (float) – The rotation to apply to the texture.
• rotationAnchor (System.Nullable<Vector2>) – The anchor for rotation, or null to use the top-left corner.
• flipHorizontally (bool) – If set to true the texture is flipped horizontally.
• flipVertically (bool) – If set to true the texture is flipped vertically.
• sourceArea (System.Nullable<Rectangle>) – The source area of the texture (defaults to the full texture).

void RenderTexture(IRenderContext context, Vector2 position, Texture2D texture, System.Nullable<Vector2> size, System.Nullable<Color> color, float rotation, System.Nullable<Vector2> rotationAnchor, bool flipHorizontally, bool flipVertically, System.Nullable<Rectangle> sourceArea)

Renders a texture at the specified position.

Parameters:

• context (Protogame.IRenderContext) – The rendering context.
• position (Microsoft.Xna.Framework.Vector2) – The position to render the texture.
• texture (Microsoft.Xna.Framework.Graphics.Texture2D) – The texture.
• size (System.Nullable<Vector2>) – The size to render the texture as (defaults to the texture size).
• color (System.Nullable<Color>) – The colorization to apply to the texture.
• rotation (float) – The rotation to apply to the texture.
• rotationAnchor (System.Nullable<Vector2>) – The anchor for rotation, or null to use the top-left corner.
• flipHorizontally (bool) – If set to true the texture is flipped horizontally.
• flipVertically (bool) – If set to true the texture is flipped vertically.
• sourceArea (System.Nullable<Rectangle>) – The source area of the texture (defaults to the full texture).

void RenderCircle(IRenderContext context, Vector2 center, int radius, Color color, bool filled)

Renders a circle.

Parameters:

• context (Protogame.IRenderContext) – The rendering context.
• center (Microsoft.Xna.Framework.Vector2) – The center of the circle.
• radius (int) – The radius of the circle.
• color (Microsoft.Xna.Framework.Color) – The color of the circle.
• filled (bool) – If set to true, the circle is rendered filled.

void SuspendSpriteBatch(IRenderContext renderContext)

Suspends usage of the sprite batch so that direct rendering can occur during a 2D context.

Parameters:

• renderContext (Protogame.IRenderContext) – The current rendering context.

void ResumeSpriteBatch(IRenderContext renderContext)

Resumes usage of the sprite batch again.

Parameters:

• renderContext (Protogame.IRenderContext) – The current rendering context.

VerticalAlignment

enum VerticalAlignment : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Represents vertical alignment.

VerticalAlignment Top

The given Y value should indicate the top of what is being aligned.

VerticalAlignment Center

The given Y value should indicate the center of what is being aligned.

VerticalAlignment Bottom

The given Y value should indicate the bottom of what is being aligned.

Graphics: 3D Rendering

Note

This documentation is a work-in-progress.

The 3D rendering utilities provide common functionality for rendering textures, text and other primitives to the screen.

These utilities are only available if your game loads the Protogame3DIoCModule instead of the Protogame2DIoCModule.

I3DRenderUtilities

interface I3DRenderUtilities

The 3DRenderUtilities interface.

Vector2 MeasureText(IRenderContext context, string text, Protogame.IAssetReference<FontAsset> font)

Measures text as if it was rendered with the font asset.

Parameters:

• context (Protogame.IRenderContext) – The rendering context.
• text (string) – The text to render.
• font (Protogame.IAssetReference<FontAsset>) – The font to use for rendering.

Returns:

The T:Microsoft.Xna.Framework.Vector2.

void RenderLine(IRenderContext context, Protogame.IEffect effect, Protogame.IEffectParameterSet effectParameterSet, Vector3 start, Vector3 end, Color color)

Renders a 3D line.

Parameters:

• context (Protogame.IRenderContext) – The rendering context.
• effect (Protogame.IEffect) –
• effectParameterSet (Protogame.IEffectParameterSet) –
• start (Microsoft.Xna.Framework.Vector3) – The start of the line.
• end (Microsoft.Xna.Framework.Vector3) – The end of the line.
• color (Microsoft.Xna.Framework.Color) – The color of the line.

void RenderLine(IRenderContext context, Protogame.IEffect effect, Protogame.IEffectParameterSet effectParameterSet, Vector3 start, Vector3 end, TextureAsset texture, Vector2 startUV, Vector2 endUV)

Renders a 3D line using texture UVs.

Parameters:

• context (Protogame.IRenderContext) – The rendering context.
• effect (Protogame.IEffect) –
• effectParameterSet (Protogame.IEffectParameterSet) –
• start (Microsoft.Xna.Framework.Vector3) – The start of the line.
• end (Microsoft.Xna.Framework.Vector3) – The end of the line.
• texture (Protogame.TextureAsset) – The texture to use.
• startUV (Microsoft.Xna.Framework.Vector2) – The UV for the start of the line.
• endUV (Microsoft.Xna.Framework.Vector2) – The UV for the end of the line.

void RenderRectangle(IRenderContext context, Protogame.IEffect effect, Protogame.IEffectParameterSet effectParameterSet, Vector3 start, Vector3 end, Color color, bool filled)

Renders a rectangle.

Parameters:

• context (Protogame.IRenderContext) – The rendering context.
• effect (Protogame.IEffect) –
• effectParameterSet (Protogame.IEffectParameterSet) –
• start (Microsoft.Xna.Framework.Vector3) – The top, left, position of the rectangle.
• end (Microsoft.Xna.Framework.Vector3) – The bottom, right position of the rectangle.
• color (Microsoft.Xna.Framework.Color) – The color of the rectangle.
• filled (bool) – If set to true, the rectangle is rendered filled.

void RenderText(IRenderContext context, Protogame.IEffect effect, Protogame.IEffectParameterSet effectParameterSet, Matrix matrix, string text, Protogame.IAssetReference<FontAsset> font, HorizontalAlignment horizontalAlignment, VerticalAlignment verticalAlignment, System.Nullable<Color> textColor, bool renderShadow, System.Nullable<Color> shadowColor)

Renders text at the specified position.

Parameters:

• context (Protogame.IRenderContext) – The rendering context.
• effect (Protogame.IEffect) –
• effectParameterSet (Protogame.IEffectParameterSet) –
• matrix (Microsoft.Xna.Framework.Matrix) – The matrix.
• text (string) – The text to render.
• font (Protogame.IAssetReference<FontAsset>) – The font to use for rendering.
• horizontalAlignment (Protogame.HorizontalAlignment) – The horizontal alignment of the text (defaults to Left).
• verticalAlignment (Protogame.VerticalAlignment) – The vertical alignment of the text (defaults to Top).
• textColor (System.Nullable<Color>) – The text color (defaults to white).
• renderShadow (bool) – Whether to render a shadow on the text (defaults to true).
• shadowColor (System.Nullable<Color>) – The text shadow’s color (defaults to black).

void RenderTexture(IRenderContext context, Protogame.IEffect effect, Protogame.IEffectParameterSet effectParameterSet, Matrix matrix, Protogame.IAssetReference<TextureAsset> texture, System.Nullable<Color> color, bool flipHorizontally, bool flipVertically, System.Nullable<Rectangle> sourceArea)

Renders a texture at the specified position.

Parameters:

• context (Protogame.IRenderContext) – The rendering context.
• effect (Protogame.IEffect) –
• effectParameterSet (Protogame.IEffectParameterSet) –
• matrix (Microsoft.Xna.Framework.Matrix) – The matrix.
• texture (Protogame.IAssetReference<TextureAsset>) – The texture.
• color (System.Nullable<Color>) – The colorization to apply to the texture.
• flipHorizontally (bool) – If set to true the texture is flipped horizontally.
• flipVertically (bool) – If set to true the texture is flipped vertically.
• sourceArea (System.Nullable<Rectangle>) – The source Area.

void RenderCube(IRenderContext context, Protogame.IEffect effect, Protogame.IEffectParameterSet effectParameterSet, Matrix transform, Color color)

Renders a 3D cube from 0, 0, 0 to 1, 1, 1, applying the specified transformation.

Parameters:

• context (Protogame.IRenderContext) – The rendering context.
• effect (Protogame.IEffect) –
• effectParameterSet (Protogame.IEffectParameterSet) –
• transform (Microsoft.Xna.Framework.Matrix) – The transformation to apply.
• color (Microsoft.Xna.Framework.Color) – The color of the cube.

void RenderCube(IRenderContext context, Protogame.IEffect effect, Protogame.IEffectParameterSet effectParameterSet, Matrix transform, TextureAsset texture, Vector2 topLeftUV, Vector2 bottomRightUV)

Renders a 3D cube from 0, 0, 0 to 1, 1, 1, applying the specified transformation, with the given texture and using the specified UV coordinates for each face of the cube.

Parameters:

• context (Protogame.IRenderContext) – The rendering context.
• effect (Protogame.IEffect) –
• effectParameterSet (Protogame.IEffectParameterSet) –
• transform (Microsoft.Xna.Framework.Matrix) – The transformation to apply.
• texture (Protogame.TextureAsset) – The texture to render on the cube.
• topLeftUV (Microsoft.Xna.Framework.Vector2) – The top-left UV coordinate.
• bottomRightUV (Microsoft.Xna.Framework.Vector2) – The bottom-right UV coordinate.

void RenderPlane(IRenderContext context, Protogame.IEffect effect, Protogame.IEffectParameterSet effectParameterSet, Matrix transform, Color color)

Renders a 2D plane from 0, 0 to 1, 1, applying the specified transformation.

Parameters:

• context (Protogame.IRenderContext) – The rendering context.
• effect (Protogame.IEffect) –
• effectParameterSet (Protogame.IEffectParameterSet) –
• transform (Microsoft.Xna.Framework.Matrix) – The transformation to apply.
• color (Microsoft.Xna.Framework.Color) – The color of the plane.

void RenderPlane(IRenderContext context, Protogame.IEffect effect, Protogame.IEffectParameterSet effectParameterSet, Matrix transform, TextureAsset texture, Vector2 topLeftUV, Vector2 bottomRightUV)

Renders a 2D plane from 0, 0 to 1, 1, applying the specified transformation.

Parameters:

• context (Protogame.IRenderContext) – The rendering context.
• effect (Protogame.IEffect) –
• effectParameterSet (Protogame.IEffectParameterSet) –
• transform (Microsoft.Xna.Framework.Matrix) – The transformation to apply.
• texture (Protogame.TextureAsset) – The texture to render on the plane.
• topLeftUV (Microsoft.Xna.Framework.Vector2) – The top-left UV coordinate.
• bottomRightUV (Microsoft.Xna.Framework.Vector2) – The bottom-right UV coordinate.

void RenderCircle(IRenderContext context, Protogame.IEffect effect, Protogame.IEffectParameterSet effectParameterSet, Matrix matrix, Vector2 center, int radius, Color color, bool filled)

Renders a circle.

Parameters:

• context (Protogame.IRenderContext) – The rendering context.
• effect (Protogame.IEffect) –
• effectParameterSet (Protogame.IEffectParameterSet) –
• matrix (Microsoft.Xna.Framework.Matrix) –
• center (Microsoft.Xna.Framework.Vector2) – The center of the circle.
• radius (int) – The radius of the circle.
• color (Microsoft.Xna.Framework.Color) – The color of the circle.
• filled (bool) – If set to true, the circle is rendered filled.

Graphics: Caching

Note

This documentation is a work-in-progress.

The graphics caching module provides an API for caching the construction of index and vertex buffers.

Events (Input)

Note

This documentation is a work-in-progress.

The event system provides a general mechanism for propagating events from one part of your game to another. As opposed to the .NET events framework, the Protogame events system allows for events to be consumed by handlers, filtered at runtime, and bound with a fluent syntax.

The event system is primarily used to handle input in Protogame; this allows entities in a game to handle input events, without multiple entities receiving the same event.

Physics

Note

This documentation is a work-in-progress.

Physics in Protogame is provided by the Jitter library, a fully managed physics engine written in C#. Therefore, the physics APIs in Protogame are available on all platforms.

Most of the physics APIs are provided directly by Jitter.

Loading the module

The physics module can be loaded by including the following during creation of the dependency injection kernel:

kernel.Load<ProtogamePhysicsIoCModule>();

ConversionExtensions

class ConversionExtensions : System.Object

Provides extension methods for converting between Jitter and XNA / MonoGame data structures.

public JVector ToJitterVector(Vector3 vector)

Convert the XNA vector to a Jitter vector.

Parameters:

• vector (Microsoft.Xna.Framework.Vector3) – The XNA vector.

Returns:

The Jitter representation of the XNA vector.

public Matrix ToXNAMatrix(JMatrix matrix)

Convert the Jitter matrix to an XNA matrix.

Parameters:

• matrix (Jitter.LinearMath.JMatrix) – The Jitter matrix.

Returns:

The XNA representation of the Jitter matrix.

public JMatrix ToJitterMatrix(Matrix matrix)

Convert the XNA matrix to a Jitter matrix.

Parameters:

• matrix (Microsoft.Xna.Framework.Matrix) – The XNA matrix.

Returns:

The Jitter representation of the XNA matrix.

public Vector3 ToXNAVector(JVector vector)

Converts the Jitter vector to an XNA vector.

Parameters:

• vector (Jitter.LinearMath.JVector) – The Jitter vector.

Returns:

The XNA representation of the Jitter vector.

public JQuaternion ToJitterQuaternion(Quaternion quat)

Converts the XNA quaternion to an Jitter quaternion.

Parameters:

• quat (Microsoft.Xna.Framework.Quaternion) – The XNA quaternion.

Returns:

The Jitter representation of the XNA quaternion.

public Quaternion ToXNAQuaternion(JQuaternion quat)

Converts the Jitter quaternion to an XNA quaternion.

Parameters:

• quat (Jitter.LinearMath.JQuaternion) – The Jitter quaternion.

Returns:

The XNA representation of the Jitter quaternion.

GeneralPhysicsEventBinder

class GeneralPhysicsEventBinder : System.Object, Protogame.IEventBinder<IPhysicsEventContext>

A general event binder for the physics system which dispatches events to only the entities involved in those events. This event binder is automatically bound when you load T:Protogame.ProtogamePhysicsModule, but you can implement your own additional event binders if you want to dispatch physics events to other unrelated entities or services in your game.

readonly int Priority

The priority of this event binder. Event binders with lower priority values will have the opportunity to consume events first.

public void Assign(IKernel kernel)

Assigns the dependency injection kernel to this instance.

Parameters:

• kernel (Protoinject.IKernel) – The dependency injection kernel.

public bool Handle(IPhysicsEventContext context, Protogame.IEventEngine<IPhysicsEventContext> eventEngine, Event event)

Handles physics events raised by the physics event engine.

Parameters:

• context (Protogame.IPhysicsEventContext) – The physics event context, which doesn’t contain any information.
• eventEngine (Protogame.IEventEngine<IPhysicsEventContext>) – The event engine for physics events.
• event (Protogame.Event) – The physics event that is being handled.

Returns:

Whether the physics event was consumed by this event binder.

IPhysicsEventContext

interface IPhysicsEventContext

The event context when a physics event is raised. This interface doesn’t actually contain any useful information; all of the data is stored in the physics event that is raised.

IPhysicsWorldControl

interface IPhysicsWorldControl

This interface provides control over the physics properties of the current world.

Vector3 Gravity

The gravity in the current world.

Jitter.Dynamics.MaterialCoefficientMixingType MaterialCoefficientMixing

The coefficient mixing to use for physics collisions in the world. When two bodies collide, this determines the strategy to use for calculating static friction, dynamic friction and restitution between the two bodies.

System.Func<RigidBody, RigidBody, Boolean> ConsiderAngularVelocityCallback

Optionally set a callback which determines whether or not angular velocity should be considered between two bodies that are colliding.

For most scenarios, you want to leave this unset, which means angular velocity will always be considered during collisions.

System.Func<RigidBody, RigidBody, Single> CalculateStaticFrictionCallback

Optionally set a callback that returns the static friction between two bodies when they collide. This is used if P:Protogame.IPhysicsWorldControl.MaterialCoefficientMixing is set to F:Jitter.Dynamics.ContactSettings.MaterialCoefficientMixingType.UseCallback.

System.Func<RigidBody, RigidBody, Single> CalculateDynamicFrictionCallback

Optionally set a callback that returns the dynamic friction between two bodies when they collide. This is used if P:Protogame.IPhysicsWorldControl.MaterialCoefficientMixing is set to F:Jitter.Dynamics.ContactSettings.MaterialCoefficientMixingType.UseCallback.

System.Func<RigidBody, RigidBody, Single> CalculateRestitutionCallback

Optionally set a callback that returns the restitution between two bodies when they collide. This is used if P:Protogame.IPhysicsWorldControl.MaterialCoefficientMixing is set to F:Jitter.Dynamics.ContactSettings.MaterialCoefficientMixingType.UseCallback.

bool EnableSpeculativeContacts

Speculative contacts increases collision accuracy and reduces the number of situations where rigid bodies get stuck inside each other. However, it can also impact material coefficient calculations by preventing objects from ever being considered to have collided. Speculative contacts is turned on by default in Protogame.

void SyncPendingChanges()

This is an internal method used to synchronise pending changes to the physics world. The internal physics world state is not always available when users of this interface set properties, so this method is called by the engine hook to ensure those changes are propagated to the physics world when it becomes available.

PhysicsCharacterController

class PhysicsCharacterController : Constraint, IConstraint, IDebugDrawable, System.IComparable<Constraint>

A simple physics-based character controller.

readonly JitterWorld World

JVector TargetVelocity

bool TryJump

RigidBody BodyWalkingOn

float JumpVelocity

float Stiffness

readonly bool OnFloor

public void DebugDraw(IDebugDrawer drawer)

Parameters:

• drawer (Jitter.IDebugDrawer) –

public void PrepareForIteration(float timestep)

Parameters:

• timestep (float) –

public void Iterate()

PhysicsCollisionBeginEvent

class PhysicsCollisionBeginEvent : Protogame.PhysicsEvent

An event that signals that two rigid bodies have started colliding in the game.

readonly RigidBody Body1

The first body involved in the collision.

readonly RigidBody Body2

The second body involved in the collision.

readonly System.Object Owner1

The owner of the first body.

readonly System.Object Owner2

The owner of the second body.

PhysicsCollisionEndEvent

class PhysicsCollisionEndEvent : Protogame.PhysicsEvent

An event that signals that two rigid bodies have stopped colliding in the game.

readonly RigidBody Body1

The first body involved in the collision.

readonly RigidBody Body2

The second body involved in the collision.

readonly System.Object Owner1

The owner of the first body.

readonly System.Object Owner2

The owner of the second body.

PhysicsTarget

enum PhysicsTarget : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Indicates the target that the physics engine will synchronise to.

PhysicsTarget ComponentOwner

Indicates that the physics system should synchronise position and rotation changes made by the physics engine against the component owner (usually the entity) that owns this component. When this option is selected, the position and rotation of the entity changes.

PhysicsTarget Component

Indicates that the physics system should synchronise position and rotation changes made by the physics engine against the component itself. When this option is selected, the position and rotation of the component changes (in the Transform property of the component).

ProtogamePhysicsModule

class ProtogamePhysicsModule : System.Object, IProtoinjectModule

This modules provides services and implementations related to physics in a game. You can load it by calling M:Protoinject.IKernel.Load``1 during the execution of M:Protogame.IGameConfiguration.ConfigureKernel(Protoinject.IKernel).

public void Load(IKernel kernel)

Parameters:

• kernel (Protoinject.IKernel) –

Level Management

The level module provides services for loading Ogmo Editor or Tiled levels into a currently running world.

Loading the module

The level module can be loaded by including the following during creation of the dependency injection kernel:

kernel.Load<ProtogameLevelIoCModule>();

ILevelManager

The level manager service provides a simple mechanism for loading a level into a world. It has one method, Load, which accepts a reference to the current world and the name of the level asset. In the context of a world, it can be used like so:

this.m_LevelManager.Load(this, "level.MyLevel");

The default level manager implementation uses the ILevelReader service to load entities, before it adds them to the world.

Please note that calling Load does not remove previous entities from the world, so if you are loading a different level, remember to remove all entities from the world that you do not want to have persist between levels.

ILevelReader

The level reader service provides a low-level mechanism for converting a stream into an enumerable of IEntity.

By default, the implementation bound to this service reads Ogmo Editor levels, although you could rebind this service to a different implementation, and the level manager service would thus be able to load a level format of your choice.

In order to load levels with the default Ogmo Editor reader implementation, you must bind an entity class to the ISolidEntity interface. The reader will instantiate new objects of the bound type for the “solids” layer in the Ogmo Editor level.

this.Bind<ISolidEntity>().To<MySolidEntity>();

On construction of the bound type, it is provided with 4 arguments: the X position x, Y position y, width width and height height of the solid tile. As with automatic factories, the names of the parameters in the constructor must match those listed.

When using tiles in the Ogmo Editor, you must bind tile entities with the appropriate name in the dependency injection kernel so that they can be resolved as the level is read. For example, if you use a dirt tileset in Ogmo Editor that has a name “dirt”, then you need to create the following binding.

this.Bind<ITileEntity>().To<DirtTileEntity>().Named("dirt");

On construction of DirtTileEntity, it is provided with 4 arguments; the pixel X position x, pixel Y position y, tile X position tx, and tile Y position ty. As with automatic factories, the names of the parameters in the constructor must match those listed.

API Documentation

ILevelManager

interface ILevelManager

The LevelManager interface.

void Load(System.Object context, Protogame.LevelAsset levelAssel)

Loads a level entity into the game hierarchy, with the specified context as the place to load entities. Normally you’ll pass in the game world here, but you don’t have to. For example, if you wanted to load the level into an entity group, you would pass the entity group as the context instead.

Parameters:

• context (System.Object) – Usually the current game world, but can be any object in the hierarchy.
• levelAssel (Protogame.LevelAsset) –

void Load(System.Object context, Protogame.LevelAsset levelAsset, System.Func<IPlan, Object, Boolean> filter)

Loads a level entity into the game hierarchy, with the specified context as the place to load entities. Normally you’ll pass in the game world here, but you don’t have to. For example, if you wanted to load the level into an entity group, you would pass the entity group as the context instead.

Parameters:

• context (System.Object) – Usually the current game world, but can be any object in the hierarchy.
• levelAsset (Protogame.LevelAsset) – The level to load.
• Object, Boolean> filter (System.Func<IPlan,) – An optional filter which can be used to exclude parts of the level during load.

System.Threading.Tasks.Task LoadAsync(System.Object context, Protogame.LevelAsset levelAssel)

Asynchronously loads a level entity into the game hierarchy, with the specified context as the place to load entities. Normally you’ll pass in the game world here, but you don’t have to. For example, if you wanted to load the level into an entity group, you would pass the entity group as the context instead.

Parameters:

• context (System.Object) – Usually the current game world, but can be any object in the hierarchy.
• levelAssel (Protogame.LevelAsset) –

System.Threading.Tasks.Task LoadAsync(System.Object context, Protogame.LevelAsset levelAsset, System.Func<IPlan, Object, Boolean> filter)

Asynchronously loads a level entity into the game hierarchy, with the specified context as the place to load entities. Normally you’ll pass in the game world here, but you don’t have to. For example, if you wanted to load the level into an entity group, you would pass the entity group as the context instead.

Parameters:

• context (System.Object) – Usually the current game world, but can be any object in the hierarchy.
• levelAsset (Protogame.LevelAsset) – The level to load.
• Object, Boolean> filter (System.Func<IPlan,) – An optional filter which can be used to exclude parts of the level during load.

ILevelReader

interface ILevelReader

The level reader interface that supplies services for reading level formats and returning a list of entities.

System.Collections.Generic.IEnumerable<IEntity> Read(System.IO.Stream stream, System.Object context)

Read the specified stream and return a list of constructed entities.

Parameters:

• stream (System.IO.Stream) – The stream which contains level data.
• context (System.Object) – The context in which entities are being spawned in the hierarchy. This is usually the current world, but it doesn’t have to be (e.g. if you wanted to load a level under an entity group, you would pass the entity group here).

Returns:

A list of entities to spawn within the world.

System.Collections.Generic.IEnumerable<IEntity> Read(System.IO.Stream stream, System.Object context, System.Func<IPlan, Object, Boolean> filter)

Read the specified stream and return a list of constructed entities, filtering the entities during loading.

Parameters:

• stream (System.IO.Stream) – The stream which contains level data.
• context (System.Object) – The context in which entities are being spawned in the hierarchy. This is usually the current world, but it doesn’t have to be (e.g. if you wanted to load a level under an entity group, you would pass the entity group here).
• Object, Boolean> filter (System.Func<IPlan,) – A filter to apply to the dependency injection plans before they are resolved.

Returns:

A list of entities to spawn within the world.

ITileset

interface ITileset : IEntity, IHasTransform

The Tileset interface.

IEntity Item

void SetSize(Vector2 cellSize, Vector2 tilesetSize)

The set size.

Parameters:

• cellSize (Microsoft.Xna.Framework.Vector2) – The cell size.
• tilesetSize (Microsoft.Xna.Framework.Vector2) – The tileset size.

ProtogameLevelModule

class ProtogameLevelModule : System.Object, IProtoinjectModule

The level loading module, which provides functionality for loading game levels into the current world.

public void Load(IKernel kernel)

The load.

Parameters:

• kernel (Protoinject.IKernel) –

Command Framework

Note

This documentation is a work-in-progress.

The command framework provides an in-game console with which commands can be registered. Players can open the console with ~ by default, and run commands that you have registered.

AI Framework

Note

This documentation is a work-in-progress.

The AI module provides services for natural moving AI agents.

Wall

class Wall : System.Object, IEntity, IHasTransform

Represents a wall which blocks raycasts by AI agents.

Vector2 Start

Vector2 End

bool DebugRender

Color DebugRenderWallColor

Color DebugRenderWallNormalColor

float X

float Y

float Z

readonly Vector2 Normal

readonly Protogame.ITransform Transform

readonly Protogame.IFinalTransform FinalTransform

public void Render(IGameContext gameContext, IRenderContext renderContext)

Parameters:

• gameContext (Protogame.IGameContext) –
• renderContext (Protogame.IRenderContext) –

public Vector2 NormalOf(Vector2 start, Vector2 end)

Parameters:

• start (Microsoft.Xna.Framework.Vector2) –
• end (Microsoft.Xna.Framework.Vector2) –

public void Update(IGameContext gameContext, IUpdateContext updateContext)

Parameters:

• gameContext (Protogame.IGameContext) –
• updateContext (Protogame.IUpdateContext) –

Particle Systems

Note

This documentation is a work-in-progress.

The particle systems module provides particle systems for use in 2D and 3D games.

Networking: Multiplayer

The networking module provides classes for building multiplayer games.

BooleanTimeMachine

class BooleanTimeMachine : Protogame.TimeMachine<Boolean>, Protogame.ITimeMachine<Boolean>, Protogame.ITimeMachine

A time machine for a boolean.

DoubleTimeMachine

class DoubleTimeMachine : Protogame.InterpolatedTimeMachine<Double>, Protogame.ITimeMachine<Double>, Protogame.ITimeMachine

The double time machine.

FlowControlChangedEventArgs

class FlowControlChangedEventArgs : System.EventArgs

The flow control changed event args.

bool IsGoodSendMode

Gets or sets a value indicating whether flow control is currently in good send mode.

Value:Whether flow control is in good send mode.

double PenaltyTime

Gets or sets the penalty time.

Value:The penalty time.

FlowControlChangedEventHandler

class FlowControlChangedEventHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable

The flow control changed event handler.

public void Invoke(System.Object sender, FlowControlChangedEventArgs e)

Parameters:

• sender (System.Object) –
• e (Protogame.FlowControlChangedEventArgs) –

public System.IAsyncResult BeginInvoke(System.Object sender, FlowControlChangedEventArgs e, System.AsyncCallback callback, System.Object object)

Parameters:

• sender (System.Object) –
• e (Protogame.FlowControlChangedEventArgs) –
• callback (System.AsyncCallback) –
• object (System.Object) –

public void EndInvoke(System.IAsyncResult result)

Parameters:

• result (System.IAsyncResult) –

Fragment

class Fragment : System.Object

Represents a fragment of data being sent over the network. This is used to track what fragments have been received / sent.

System.Byte[] Data

Gets or sets the raw data of the fragment.

Value:The raw data of the fragment.

FragmentStatus Status

Gets or sets the status.

Value:The status.

FragmentStatus

enum FragmentStatus : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Represents a fragment’s status.

FragmentStatus WaitingOnSend

This indicates the fragment is currently waiting to be sent. This can either be because it’s the first time the fragment is being sent, or we received a MessageLost event and we are resending it.

FragmentStatus WaitingOnAcknowledgement

This indicates the fragment has been sent, but we are waiting on either an acknowledgement or lost event to be sent relating to this fragment.

FragmentStatus Acknowledged

This indicates the fragment has been acknowledged by the remote client.

FragmentStatus WaitingOnReceive

This indicates that we know about this fragment (because we have received the header indicating the number of fragments to expect), but we haven’t received the content fragment yet.

FragmentStatus Received

This indicates the fragment has been received.

INetworkEventContext

interface INetworkEventContext

The event context when a networking event is raised. This interface doesn’t actually contain any useful information; all of the data is stored in the network event that is raised.

InputPrediction

class InputPrediction : System.Object

The input prediction.

public void Acknowledge(int count)

Mark the specified input as acknowledged, removing all actions in the prediction queue prior to this point in time.

Parameters:

• count (int) – The counter originally given by Predict.

public int Predict(System.Action action)

Place an action in the input prediction queue, and return the counter that the server needs to acknowledge.

Parameters:

• action (System.Action) – The prediction action.

Returns:

The counter that should be sent to the server for acknowledgement.

public void Replay()

Replays the list of actions that are currently not acknowledged by the server.

Int16TimeMachine

class Int16TimeMachine : Protogame.InterpolatedTimeMachine<Int16>, Protogame.ITimeMachine<Int16>, Protogame.ITimeMachine

The int 16 time machine.

Int32TimeMachine

class Int32TimeMachine : Protogame.InterpolatedTimeMachine<Int32>, Protogame.ITimeMachine<Int32>, Protogame.ITimeMachine

The int 32 time machine.

InterpolatedTimeMachine<T>

class InterpolatedTimeMachine<T> : TimeMachine<T>, Protogame.ITimeMachine<T>, Protogame.ITimeMachine

A form of time machine that supports interpolation and extrapolation of values between keys.

Type Parameters:  

• T – The type of data that will be tracked by the time machine.

public Protogame.T Get(int tick)

Retrieves the value at the specified tick, or interpolates / extrapolates a value from the known values in the time machine.

Parameters:

• tick (int) – The tick at which to retrieve the value.

Returns:

The .

protected abstract Protogame.T AddType(Protogame.T a, Protogame.T b)

Parameters:

• a (Protogame.T) –
• b (Protogame.T) –

protected abstract Protogame.T DefaultType()

Return the default value of when neither interpolation or extrapolation can be performed.

Returns:The default value.

protected abstract Protogame.T DivideType(Protogame.T b, int a)

Parameters:

• b (Protogame.T) –
• a (int) –

protected abstract Protogame.T MultiplyType(Protogame.T a, int b)

Parameters:

• a (Protogame.T) –
• b (int) –

protected abstract Protogame.T SubtractType(Protogame.T a, Protogame.T b)

Parameters:

• a (Protogame.T) –
• b (Protogame.T) –

protected abstract bool ValueIsZeroType(Protogame.T value)

Parameters:

• value (Protogame.T) –

MxClient

class MxClient : System.Object

A client on the Mx protocol.

readonly System.Net.IPEndPoint Endpoint

Gets the endpoint that this client is responsible for.

Value:The endpoint that this client is responsible for.

readonly float Latency

Gets the amount of network latency (lag) in milliseconds.

Value:The network latency.

Protogame.MxClientGroup Group

The group that this Mx client is in. You should not set this directly; instead call M:Protogame.MxDispatcher.PlaceInGroup(Protogame.MxClient,System.String).

int DisconnectLimit

The disconnection timeout limit.

int DisconnectWarningLimit

The disconnection timeout warning limit.

readonly int DisconnectAccumulator

The disconnection accumulator.

readonly bool HasReceivedPacket

Whether or not this client has ever received a packet. When a group is isolating connections via M:Protogame.MxClientGroup.Isolate, it checks this value to see whether or not the client has had successful communications as opposed to simply not having timed out yet.

public void add_DisconnectWarning(MxDisconnectEventHandler value)

Parameters:

• value (Protogame.MxDisconnectEventHandler) –

public void remove_DisconnectWarning(MxDisconnectEventHandler value)

Parameters:

• value (Protogame.MxDisconnectEventHandler) –

public void add_FlowControlChanged(FlowControlChangedEventHandler value)

Parameters:

• value (Protogame.FlowControlChangedEventHandler) –

public void remove_FlowControlChanged(FlowControlChangedEventHandler value)

Parameters:

• value (Protogame.FlowControlChangedEventHandler) –

public void add_MessageAcknowledged(MxMessageEventHandler value)

Parameters:

• value (Protogame.MxMessageEventHandler) –

public void remove_MessageAcknowledged(MxMessageEventHandler value)

Parameters:

• value (Protogame.MxMessageEventHandler) –

public void add_MessageLost(MxMessageEventHandler value)

Parameters:

• value (Protogame.MxMessageEventHandler) –

public void remove_MessageLost(MxMessageEventHandler value)

Parameters:

• value (Protogame.MxMessageEventHandler) –

public void add_MessageReceived(MxMessageReceiveEventHandler value)

Parameters:

• value (Protogame.MxMessageReceiveEventHandler) –

public void remove_MessageReceived(MxMessageReceiveEventHandler value)

Parameters:

• value (Protogame.MxMessageReceiveEventHandler) –

public void add_MessageSent(MxMessageEventHandler value)

Parameters:

• value (Protogame.MxMessageEventHandler) –

public void remove_MessageSent(MxMessageEventHandler value)

Parameters:

• value (Protogame.MxMessageEventHandler) –

public void EnqueueReceive(System.Byte[] packet)

Enqueues a byte array to be handled in the receiving logic when Update() is called.

Parameters:

• packet (System.Byte[]) – The packet’s byte data.

public void EnqueueSend(System.Byte[] packet, uint protocol)

Enqueues a byte array to be sent to the target endpoint when Update() is called.

Parameters:

• packet (System.Byte[]) – The packet’s byte data.
• protocol (uint) – The packet’s protocol type.

public void Update()

Updates the state of the Mx client, sending outgoing packets and receiving incoming packets.

MxClientEventArgs

class MxClientEventArgs : System.EventArgs

The mx client event args.

MxClient Client

Gets or sets the client.

Value:The client.

MxClientEventHandler

class MxClientEventHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable

The mx client event handler.

public void Invoke(System.Object sender, MxClientEventArgs e)

Parameters:

• sender (System.Object) –
• e (Protogame.MxClientEventArgs) –

public System.IAsyncResult BeginInvoke(System.Object sender, MxClientEventArgs e, System.AsyncCallback callback, System.Object object)

Parameters:

• sender (System.Object) –
• e (Protogame.MxClientEventArgs) –
• callback (System.AsyncCallback) –
• object (System.Object) –

public void EndInvoke(System.IAsyncResult result)

Parameters:

• result (System.IAsyncResult) –

MxDisconnectEventArgs

class MxDisconnectEventArgs : System.EventArgs

The mx client event args.

MxClient Client

Gets or sets the client.

Value:The client.

int DisconnectAccumulator

Gets or sets the disconnect accumulator.

Value:The disconnect accumulator.

int DisconnectTimeout

Gets or sets the disconnect timeout.

Value:The disconnect timeout.

bool IsDisconnected

Gets or sets a value indicating whether or not the client has disconnected.

Value:Whether or not the client has disconnected.

MxDisconnectEventHandler

class MxDisconnectEventHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable

The mx client event handler.

public void Invoke(System.Object sender, MxDisconnectEventArgs e)

Parameters:

• sender (System.Object) –
• e (Protogame.MxDisconnectEventArgs) –

public System.IAsyncResult BeginInvoke(System.Object sender, MxDisconnectEventArgs e, System.AsyncCallback callback, System.Object object)

Parameters:

• sender (System.Object) –
• e (Protogame.MxDisconnectEventArgs) –
• callback (System.AsyncCallback) –
• object (System.Object) –

public void EndInvoke(System.IAsyncResult result)

Parameters:

• result (System.IAsyncResult) –

MxDispatcher

class MxDispatcher : System.Object

The Mx dispatcher; this handles receiving messages on the UDP client and dispatching them to the correct connected Mx client.

readonly bool Closed

Gets a value indicating whether this dispatcher has been closed.

Value:Whether or not this dispatcher has been closed.

readonly Protogame.MxClientGroup Item

readonly System.Collections.Generic.IEnumerable<KeyValuePair`2> Latencies

Gets an enumeration of the latencies for all connected endpoints.

Value:An enumeration of the latencies for all connected endpoints.

readonly System.Collections.Generic.IEnumerable<MxClientGroup> AllClientGroups

readonly System.Collections.Generic.IEnumerable<MxClientGroup> ValidClientGroups

public void add_ClientConnected(MxClientEventHandler value)

Parameters:

• value (Protogame.MxClientEventHandler) –

public void remove_ClientConnected(MxClientEventHandler value)

Parameters:

• value (Protogame.MxClientEventHandler) –

public void add_ClientDisconnectWarning(MxDisconnectEventHandler value)

Parameters:

• value (Protogame.MxDisconnectEventHandler) –

public void remove_ClientDisconnectWarning(MxDisconnectEventHandler value)

Parameters:

• value (Protogame.MxDisconnectEventHandler) –

public void add_ClientDisconnected(MxClientEventHandler value)

Parameters:

• value (Protogame.MxClientEventHandler) –

public void remove_ClientDisconnected(MxClientEventHandler value)

Parameters:

• value (Protogame.MxClientEventHandler) –

public void add_MessageAcknowledged(MxMessageEventHandler value)

Parameters:

• value (Protogame.MxMessageEventHandler) –

public void remove_MessageAcknowledged(MxMessageEventHandler value)

Parameters:

• value (Protogame.MxMessageEventHandler) –

public void add_MessageLost(MxMessageEventHandler value)

Parameters:

• value (Protogame.MxMessageEventHandler) –

public void remove_MessageLost(MxMessageEventHandler value)

Parameters:

• value (Protogame.MxMessageEventHandler) –

public void add_MessageReceived(MxMessageEventHandler value)

Parameters:

• value (Protogame.MxMessageEventHandler) –

public void remove_MessageReceived(MxMessageEventHandler value)

Parameters:

• value (Protogame.MxMessageEventHandler) –

public void add_MessageSent(MxMessageEventHandler value)

Parameters:

• value (Protogame.MxMessageEventHandler) –

public void remove_MessageSent(MxMessageEventHandler value)

Parameters:

• value (Protogame.MxMessageEventHandler) –

public void add_ReliableReceivedProgress(MxReliabilityTransmitEventHandler value)

Parameters:

• value (Protogame.MxReliabilityTransmitEventHandler) –

public void remove_ReliableReceivedProgress(MxReliabilityTransmitEventHandler value)

Parameters:

• value (Protogame.MxReliabilityTransmitEventHandler) –

public void add_ReliableSendProgress(MxReliabilityTransmitEventHandler value)

Parameters:

• value (Protogame.MxReliabilityTransmitEventHandler) –

public void remove_ReliableSendProgress(MxReliabilityTransmitEventHandler value)

Parameters:

• value (Protogame.MxReliabilityTransmitEventHandler) –

public void Close()

Closes the dispatcher permanently, terminating all inbound and outbound connections.

public Protogame.MxClientGroup PlaceInGroup(MxClient client, string identifier)

Places the specified Mx client in the specified group.

Parameters:

• client (Protogame.MxClient) – The Mx client.
• identifier (string) – The group identifier.

public MxClient Connect(System.Net.IPEndPoint endpoint)

Explicitly connect to the specified endpoint, assuming there is an Mx dispatcher at the specified address.

This method is used to explicitly add clients, not to start the dispatcher. The dispatcher does not require an explicit start.

Parameters:

• endpoint (System.Net.IPEndPoint) – The endpoint to connect to.

public void Disconnect(Protogame.MxClientGroup clientGroup)

Disconnects the entire Mx client group, disconnecting all clients inside it.

Parameters:

• clientGroup (Protogame.MxClientGroup) – The client group.

public void Disconnect(MxClient client)

Disconnects the specified Mx client. This removes it from the group that owns it, and prevents it from reconnecting to this dispatcher implicitly.

Parameters:

• client (Protogame.MxClient) – The client.

public int GetBytesLastReceivedAndReset()

public int GetBytesLastSentAndReset()

public void Send(Protogame.MxClientGroup group, System.Byte[] packet, bool reliable)

Queue a packet for sending to the specified endpoint.

Parameters:

• group (Protogame.MxClientGroup) – The group to send the message to.
• packet (System.Byte[]) – The associated data to send.
• reliable (bool) – Whether or not this message should be sent reliably and intact. This also permits messages larger than 512 bytes to be sent.

public void Send(MxClient client, System.Byte[] packet, bool reliable)

Queue a packet for sending to the specified client.

Parameters:

• client (Protogame.MxClient) – The client to send the message to.
• packet (System.Byte[]) – The associated data to send.
• reliable (bool) – Whether or not this message should be sent reliably and intact. This also permits messages larger than 512 bytes to be sent.

public void Update()

Updates the dispatcher, receiving messages and connecting clients as appropriate.

MxMessage

class MxMessage : System.Object

The message class that represents a message being transferred over the Mx protocol.

uint RealtimeProtocol

Indicates the message is for the real time protocol.

uint ReliableProtocol

Indicates the message is for the reliable protocol.

uint Ack

Gets or sets the latest sequence number this packet is acknowledging.

Value:The latest sequence number this packet is acknowledging.

uint AckBitfield

Gets or sets the ack bitfield, which represents of the last 32 acks, which have been acknowledged.

Value:The ack bitfield, which represents of the last 32 acks, which have been acknowledged.

Protogame.MxPayload[] Payloads

Gets or sets the payloads for this message.

Value:The payloads associated with this message.

uint ProtocolID

Gets or sets the protocol ID.

Value:The protocol ID.

uint Sequence

Gets or sets the sequence number.

Value:The sequence number.

public bool DidAck(uint sequence)

Returns whether this message did acknowledge the specified sequence number.

Parameters:

• sequence (uint) – The sequence number to check.

Returns:

Whether this message acknowledges the specified sequence number.

public System.Boolean[] GetAckBitfield()

Converts the bitfield into an array of T:System.Boolean.

Returns:The array of T:System.Boolean representing the acknowledgement status.

public bool HasAck(uint sequence)

Returns whether or not this message can acknowledge the specified sequence number. This will return false if the specified sequence number is more than 32 messages ago.

Parameters:

• sequence (uint) – The sequence number to check.

Returns:

Whether this message can acknowledge the specified sequence number.

public void SetAckBitfield(System.Boolean[] received)

Sets the bitfield based on an input array of T:System.Boolean.

Parameters:

• received (System.Boolean[]) – The array of T:System.Boolean representing the acknowledgement status.

MxMessageEventArgs

class MxMessageEventArgs : System.EventArgs

The mx message event args.

MxClient Client

Gets or sets the client.

Value:The client.

System.Byte[] Payload

Gets or sets the payload of the message.

Value:The payload of the message.

uint ProtocolID

Gets or sets the protocol ID of the message.

Value:The protocol ID of the message.

MxMessageEventHandler

class MxMessageEventHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable

The mx message event handler.

public void Invoke(System.Object sender, MxMessageEventArgs e)

Parameters:

• sender (System.Object) –
• e (Protogame.MxMessageEventArgs) –

public System.IAsyncResult BeginInvoke(System.Object sender, MxMessageEventArgs e, System.AsyncCallback callback, System.Object object)

Parameters:

• sender (System.Object) –
• e (Protogame.MxMessageEventArgs) –
• callback (System.AsyncCallback) –
• object (System.Object) –

public void EndInvoke(System.IAsyncResult result)

Parameters:

• result (System.IAsyncResult) –

MxMessageReceiveEventArgs

class MxMessageReceiveEventArgs : MxMessageEventArgs

The mx message event args.

bool DoNotAcknowledge

Gets or sets whether the client should not acknowledge this message.

Value:Set to true if the client should not acknowledge this message has been received. This can be used when the packet is invalid or the receiver has no way of determining what to do with it.

MxMessageReceiveEventHandler

class MxMessageReceiveEventHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable

The mx message receive event handler.

public void Invoke(System.Object sender, MxMessageReceiveEventArgs e)

Parameters:

• sender (System.Object) –
• e (Protogame.MxMessageReceiveEventArgs) –

public System.IAsyncResult BeginInvoke(System.Object sender, MxMessageReceiveEventArgs e, System.AsyncCallback callback, System.Object object)

Parameters:

• sender (System.Object) –
• e (Protogame.MxMessageReceiveEventArgs) –
• callback (System.AsyncCallback) –
• object (System.Object) –

public void EndInvoke(System.IAsyncResult result)

Parameters:

• result (System.IAsyncResult) –

MxMessageSerializer

class MxMessageSerializer : ProtoBuf.Meta.TypeModel

This is a Protobuf serializer that serializes and deserializes the MxMessage class.

MxPayload

class MxPayload : System.Object

Encapsulates an Mx payload. We have a seperate class since we need an array of byte arrays, which can’t be represented directly in Protobuf.

System.Byte[] Data

Gets or sets the data.

Value:The data of the payload.

MxReliability

class MxReliability : System.Object

The class that provides reliability and fragmentation infrastructure for Mx clients.

This class is used by T:Protogame.MxDispatcher to interface with an T:Protogame.MxClient in a reliable manner. When data is sent reliably, this class is used to fragment and reconstruct sets of data, ensuring that each fragment is either acknowledged by the receiving machine, or sent again.

int SafeFragmentSize

The safe fragment size.

readonly MxClient Client

The underlying Mx client instance.

public void add_FragmentReceived(MxReliabilityTransmitEventHandler value)

Parameters:

• value (Protogame.MxReliabilityTransmitEventHandler) –

public void remove_FragmentReceived(MxReliabilityTransmitEventHandler value)

Parameters:

• value (Protogame.MxReliabilityTransmitEventHandler) –

public void add_FragmentSent(MxReliabilityTransmitEventHandler value)

Parameters:

• value (Protogame.MxReliabilityTransmitEventHandler) –

public void remove_FragmentSent(MxReliabilityTransmitEventHandler value)

Parameters:

• value (Protogame.MxReliabilityTransmitEventHandler) –

public void add_MessageAcknowledged(MxMessageEventHandler value)

Parameters:

• value (Protogame.MxMessageEventHandler) –

public void remove_MessageAcknowledged(MxMessageEventHandler value)

Parameters:

• value (Protogame.MxMessageEventHandler) –

public void add_MessageReceived(MxMessageEventHandler value)

Parameters:

• value (Protogame.MxMessageEventHandler) –

public void remove_MessageReceived(MxMessageEventHandler value)

Parameters:

• value (Protogame.MxMessageEventHandler) –

public void Send(System.Byte[] data)

Sends data to the associated client reliably.

Parameters:

• data (System.Byte[]) – The data to be sent.

public void Update()

Updates this reliability class, sending and receiving messages as required.

MxReliabilityReceiveState

class MxReliabilityReceiveState : System.Object

Represents the current receive state of a reliable message.

readonly int CurrentReceiveMessageID

The ID of the message we are currently receiving; this binds packets to the original header so that in the case of duplicated sends we can’t get packets that aren’t associated with the given header.

Value:The current receive message id.

readonly int TotalFragments

The total number of fragments that this message contains.

Value:The total fragments.

public bool IsComplete()

The is complete.

Returns:The T:System.Boolean.

public System.Byte[] Reconstruct()

The reconstruct.

Returns:The :byte[].

public void SetFragment(int currentIndex, Fragment fragment)

The set fragment.

Parameters:

• currentIndex (int) – The current index.
• fragment (Protogame.Fragment) – The fragment.

MxReliabilitySendState

class MxReliabilitySendState : System.Object

Represents the current send state of a reliable message.

System.Collections.Generic.List<Fragment> CurrentSendFragments

A list of fragments that are currently being sent. Each of the fragments is used to track whether or not it has been acknowledged by the remote client.

System.Byte[] CurrentSendMessage

The current message that is being sent.

int CurrentSendMessageID

The ID of the message we are currently sending.

public bool MarkFragmentIfPresent(System.Byte[] data, FragmentStatus newStatus)

Parameters:

• data (System.Byte[]) –
• newStatus (Protogame.FragmentStatus) –

public bool HasPendingSends()

MxReliabilityTransmitEventArgs

class MxReliabilityTransmitEventArgs : System.EventArgs

The mx message event args.

MxClient Client

Gets or sets the client.

Value:The client.

int CurrentFragments

Gets or sets the current fragments.

Value:The current fragments.

bool IsSending

Gets or sets a value indicating whether is sending.

Value:The is sending.

int TotalFragments

Gets or sets the total fragments.

Value:The total fragments.

int TotalSize

Gets or sets the total size.

Value:The total size.

MxReliabilityTransmitEventHandler

class MxReliabilityTransmitEventHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable

The mx message event handler.

public void Invoke(System.Object sender, MxReliabilityTransmitEventArgs e)

Parameters:

• sender (System.Object) –
• e (Protogame.MxReliabilityTransmitEventArgs) –

public System.IAsyncResult BeginInvoke(System.Object sender, MxReliabilityTransmitEventArgs e, System.AsyncCallback callback, System.Object object)

Parameters:

• sender (System.Object) –
• e (Protogame.MxReliabilityTransmitEventArgs) –
• callback (System.AsyncCallback) –
• object (System.Object) –

public void EndInvoke(System.IAsyncResult result)

Parameters:

• result (System.IAsyncResult) –

MxUtility

class MxUtility : System.Object

The mx utility.

int UIntBitsize

The u int bitsize.

public long GetSequenceNumberDifference(uint new, uint current)

Gets the sequence number difference between the “new” and “current” messages. If the “new” sequence ID represents a later message, then the result is positive; if the “new” sequence ID represents an older message, then the result is negative.

Parameters:

• new (uint) –
• current (uint) –

Returns:

The T:System.Int64.

SingleTimeMachine

class SingleTimeMachine : Protogame.InterpolatedTimeMachine<Single>, Protogame.ITimeMachine<Single>, Protogame.ITimeMachine

The single time machine.

StringTimeMachine

class StringTimeMachine : Protogame.TimeMachine<String>, Protogame.ITimeMachine<String>, Protogame.ITimeMachine

A time machine for a string.

TimeMachine<T>

class TimeMachine<T> : System.Object, Protogame.ITimeMachine<T>, Protogame.ITimeMachine

This class facilitates lag compensation and value prediction for data that is being synchronized over a latent stream (such as a network connection). For interpolation and extrapolation, use T:Protogame.InterpolatedTimeMachine`1.

Type Parameters:  

• T – The type of data that will be tracked by the time machine.

readonly System.Type Type

The type of the values stored by this time machine.

public void FindSurroundingTickValues(System.Collections.Generic.IList<Int32> keys, int current, ref int previous, ref int next)

Parameters:

• keys (System.Collections.Generic.IList<Int32>) –
• current (int) –
• (ref) previous (int) –
• (ref) next (int) –

public Protogame.T Get(int tick)

Retrieves the value at the specified tick, or interpolates / extrapolates a value from the known values in the time machine.

Parameters:

• tick (int) – The tick at which to retrieve the value.

Returns:

The .

public void Purge(int tick)

Purges old history in the time machine, freeing up memory.

Parameters:

• tick (int) – The current tick. This value minus the history setting will be the tick from which older ticks will be removed.

public void Set(int tick, System.Object value)

Sets the specified tick and value into the time machine. Once you have set a value at a specified time, you can only set values with a higher tick.

Parameters:

• tick (int) – The tick at which this value exists.
• value (System.Object) – The value to store in the time machine.

public void Set(int tick, Protogame.T value)

Parameters:

• tick (int) –
• value (Protogame.T) –

TransformTimeMachine

class TransformTimeMachine : Protogame.TimeMachine<ITransform>, Protogame.ITimeMachine<ITransform>, Protogame.ITimeMachine

A time machine for transforms.

public Protogame.ITransform Get(int tick)

Parameters:

• tick (int) –

public void Set(int tick, System.Object value)

Parameters:

• tick (int) –
• value (System.Object) –

Vector3TimeMachine

class Vector3TimeMachine : Protogame.InterpolatedTimeMachine<Vector3>, Protogame.ITimeMachine<Vector3>, Protogame.ITimeMachine

A time machine for the Vector3 structure.

Networking: Dedicated Servers

Note

This documentation is a work-in-progress.

The server module in Protogame provides a framework for writing dedicated servers. It contains entity and world interfaces suitable for dedicated servers, where graphics APIs are not available.

Scripting and Modding

Note

This documentation is a work-in-progress.

The scripting module provides mechanisms for loading and executing scripts written in a shader-like language called LogicControl. LogicControl is implemented purely in C#, and can be used on all platforms.

Like shaders, method parameters and return values in LogicControl have semantics declared on them, which are then used to call scripts from C#. Scripts are integrated into the asset management system, so scripts are loaded through the standard asset management system, while still being available on disk for players to modify.

The scripting module also supports being extended with different languages, by creating new implementations of IScriptEngine and IScriptEngineInstance.

Thus the Protogame scripting module provides an extremely easy way of providing modding and extension APIs for your games.

Hardware Sensors

Note

This documentation is a work-in-progress.

Warning

The camera sensor APIs are currently only available on Windows Desktop.

The sensor module provides access to hardware attached to the machine or device that your game is running on. Currently this includes only camera devices, but we expect this will expand in future to provide abstractions for location and accelerometer sensors.

ICamera

interface ICamera

A camera sensor on the current device.

readonly string Name

The user-friendly name of the camera hardware.

readonly int Width

The width of the images captured by this camera.

readonly int Height

The height of images captured by this camera.

ICameraSensor

interface ICameraSensor : ISensor

A sensor which represents all available cameras on the current device.

readonly Texture2D VideoCaptureFrame

The texture representing what the currently active camera is capturing. This value may be null if no active camera is set, or if the image from the active camera is not ready.

readonly System.Byte[] VideoCaptureUnlockedRGBA

The raw RGBA data from the camera. This data is written to by another thread, which means that it is not atomically correct. The data in this array may be written to as you are reading from it.

readonly System.Nullable<Int32> VideoCaptureWidth

The width of the current texture, or null if no texture is currently available.

readonly System.Nullable<Int32> VideoCaptureHeight

The height of the current texture, or null if no texture is currently available.

ICamera ActiveCamera

The currently active camera. This is initially null, and you need to set this value to one of the cameras returned by M:Protogame.ICameraSensor.GetAvailableCameras.

System.Collections.Generic.List<ICamera> GetAvailableCameras()

Gets all of the available cameras on this device.

Returns:

ISensor

interface ISensor

An abstract sensor attached to this device.

void Render(IGameContext gameContext, IRenderContext renderContext)

Updates the sensor during the render step of the game.

Parameters:

• gameContext (Protogame.IGameContext) – The current game context.
• renderContext (Protogame.IRenderContext) – The current render context.

void Update(IGameContext gameContext, IUpdateContext updateContext)

Updates the sensor during the update step of the game.

Parameters:

• gameContext (Protogame.IGameContext) – The current game context.
• updateContext (Protogame.IUpdateContext) – The current update context.

ISensorEngine

interface ISensorEngine

The sensor engine which automatically updates registered sensors.

Because hardware sensors may activate hardware components, or may require additional permissions on some operating systems, they are not activated by default. Instead, you need to M:Protogame.ISensorEngine.Register(Protogame.ISensor) sensors after you inject them into your class.

void Render(IGameContext gameContext, IRenderContext renderContext)

Internally called by T:Protogame.SensorEngineHook to update sensors during the render step.

Parameters:

• gameContext (Protogame.IGameContext) – The current game context.
• renderContext (Protogame.IRenderContext) – The current render context.

void Update(IGameContext gameContext, IUpdateContext updateContext)

Internally called by T:Protogame.SensorEngineHook to update sensors during the update step.

Parameters:

• gameContext (Protogame.IGameContext) – The current game context.
• updateContext (Protogame.IUpdateContext) – The current update context.

void Register(ISensor sensor)

Registers a hardware sensor with the sensor engine, ensuring that it is updated as the game runs.

Parameters:

• sensor (Protogame.ISensor) – The hardware sensor to register.

void Deregister(ISensor sensor)

Deregisters a hardware sensor from the sensor engine, ensuring that it is no longer updated as the game runs.

Parameters:

• sensor (Protogame.ISensor) – The hardware sensor to deregister.

UI Framework

Note

This documentation is a work-in-progress.

The UI framework module provides a powerful UI system in Protogame.

Engine Utilities

Protogame provides various smaller utility APIs that serve very specific purposes. These APIs are often only used for specific games, or when targeting specific platforms.

Analytics Reporting

Note

This documentation is a work-in-progress.

The analytics module provides APIs which allow you to track player behaviour in-game, and submit it to online services such as GameAnalytics.

Performance Profiling

Note

This documentation is a work-in-progress.

The performance profiling module allows you to profile events and method calls in Protogame-based games.

This API provides both a general API for measuring the length of events explicitly, and an automatic profiling system for desktop platforms.

Warning

The automatic profiling mechanism is only available on desktop platforms, but works without requiring developers to explicitly scope measured events.

Compression Utilities

The compression utilities inside Protogame provide helper methods which compress byte arrays using the LZMA algorithm.

The compression utilities do not require loading a module; instead use the LzmaHelper class directly.

LzmaHelper.Compress

This method takes an input (uncompressed) stream and an output stream.

To compress a byte array, use this method in conjunction with the MemoryStream class available in .NET:

byte[] uncompressedBytes;
byte[] compressedBytes;

using (var input = new MemoryStream(uncompressedBytes))
{
    using (var output = new MemoryStream())
    {
        LzmaHelper.Compress(input, output);
        var length = output.Position;
        compressedBytes = new byte[length];
        output.Seek(SeekOrigin.Begin, 0);
        output.Read(compressedBytes, 0, length);
    }
}

LzmaHelper.Decompress

This method takes an input (compressed) stream and an output stream.

To compress a byte array, use this method in conjunction with the MemoryStream class available in .NET:

byte[] uncompressedBytes;
byte[] compressedBytes;

using (var input = new MemoryStream(compressedBytes))
{
    using (var output = new MemoryStream())
    {
        LzmaHelper.Decompress(input, output);
        var length = output.Position;
        uncompressedBytes = new byte[length];
        output.Seek(SeekOrigin.Begin, 0);
        output.Read(uncompressedBytes, 0, length);
    }
}

Primitive Collisions

Note

This documentation is a work-in-progress.

The collisions module provides basic, non-physics collision checking on primitives, such as triangle-triangle intersection tests.

Image Processing

Note

This documentation is a work-in-progress.

The image processing module allows you to process images in memory and extract meaningful information from them. When combined with the Hardware Sensors API, this can be used to create augmented reality games.

IColorInImageDetection

interface IColorInImageDetection : System.IDisposable

An interface that represents an implementation which detects the color in images (from a given image source) and returns locations in the image where the color appears in high concentrations.

This interface must be constructed using T:Protogame.IImageProcessingFactory. Because it processes data in a background thread, you must call M:Protogame.IColorInImageDetection.Start to begin the actual image analysis.

float GlobalSensitivity

The global sensitivity used to detect color in the image. This is preset at a sensible default, so you should not really need to change this value.

int ChunkSize

The size of chunks to perform the analysis with. The smaller this value, the exponentially larger number of sections the algorithm has to scan over.

In testing, we have found that for a 640x480 image source, a chunk size of 5 is a reasonable value. This is the default value. If scanning larger images, or if you’re finding the results are being processed too slowly on the background thread, you may need to set this property to a higher value.

Once M:Protogame.IColorInImageDetection.Start has been called, you can not change this value. If you need to change the chunk size after image analysis has been started, you need to M:System.IDisposable.Dispose of this instance and create a new one using the T:Protogame.IImageProcessingFactory factory.

Protogame.ISelectedColorHandle RegisterColorForAnalysis(Color color, string name)

Registers a color for detection. The implementation will continuosly scan the image source on a background thread to detect this color in the image.

You can register multiple colors for detection by calling this method multiple times.

This method returns a handle which you can then use in other methods on this interface to get the results of scanning for this color.

Parameters:

• color (Microsoft.Xna.Framework.Color) – The color to detect in the image.
• name (string) – The name of the color for diagnostic purposes.

Returns:

System.Int32[,] GetUnlockedResultsForColor(Protogame.ISelectedColorHandle handle)

Returns a two-dimensional integer array representing the strength of color detected in the image.

When the image is analysed, it is split up into a grid of chunks, where each chunk is P:Protogame.IColorInImageDetection.ChunkSize`x:ref:`P:Protogame.IColorInImageDetection.ChunkSize pixels in size. Each chunk is represented by a single integer in the array. Thus if you map the array returned by this method onto the screen, using a P:Protogame.IColorInImageDetection.ChunkSize`x:ref:`P:Protogame.IColorInImageDetection.ChunkSize rectangle to represent each value going across and then down, you will see the analysis of the original image with the desired color represented as high integer values.

In the returned array, negative values represent a lack of the requested color, while positive values represent a presence of the requested color. Neutral values (close to 0) represent parts of the image which are neither strongly correlated or strongly against the desired color.

For example, if you were detecting the color red, and you had a picture of a blue object in the image source, this array would be filled with a large amount of negative values representing the blue object in the image. If you had a very red object in the image, you would see very high positive integers representing the presence of that object.

In testing, and with the default global sensitivity, we have found that a threshold of positive 100 (after dividing the value by the color’s local sensivity; see M:Protogame.IColorInImageDetection.GetSensitivityForColor(Protogame.ISelectedColorHandle)) represents the precense of a color in an image, while lower values represent neutral or opposite of colors. However, you should be aware that you might need to offer calibration of global sensitivity in your game if your image source is from an external camera, as different lighting conditions may require a different sensitivity level.

Parameters:

• handle (Protogame.ISelectedColorHandle) – The color handle returned by M:Protogame.IColorInImageDetection.RegisterColorForAnalysis(Microsoft.Xna.Framework.Color,System.String).

Returns:

The two-dimensional integer array representing the strength of color in the image.

float GetSensitivityForColor(Protogame.ISelectedColorHandle handle)

Gets the localised sensitivity value for the specified color.

Because images may contain varying amounts of a specific color in them, the color detection algorithm attempts to normalize the sensitivity on a per-color basis, depending on how much of the image contains that color.

You should divide the integers inside M:Protogame.IColorInImageDetection.GetUnlockedResultsForColor(Protogame.ISelectedColorHandle) by this value to determine the actual score.

Parameters:

• handle (Protogame.ISelectedColorHandle) – The color handle returned by M:Protogame.IColorInImageDetection.RegisterColorForAnalysis(Microsoft.Xna.Framework.Color,System.String).

Returns:

The sensitivity calculated for the color.

int GetTotalDetectedForColor(Protogame.ISelectedColorHandle handle)

Gets the total amount of color detected in the image.

This value is primarily useful for diagnositic purposes.

Parameters:

• handle (Protogame.ISelectedColorHandle) – The color handle returned by M:Protogame.IColorInImageDetection.RegisterColorForAnalysis(Microsoft.Xna.Framework.Color,System.String).

Returns:

The total amount of color detected in the image.

string GetNameForColor(Protogame.ISelectedColorHandle handle)

Gets the name of the color when it was originally registered.

Parameters:

• handle (Protogame.ISelectedColorHandle) – The color handle returned by M:Protogame.IColorInImageDetection.RegisterColorForAnalysis(Microsoft.Xna.Framework.Color,System.String).

Returns:

The name of the color when it was originally registered.

Color GetValueForColor(Protogame.ISelectedColorHandle handle)

Gets the color value of the color when it was originally registered.

Parameters:

• handle (Protogame.ISelectedColorHandle) – The color handle returned by M:Protogame.IColorInImageDetection.RegisterColorForAnalysis(Microsoft.Xna.Framework.Color,System.String).

Returns:

The color value of the color when it was originally registered.

void Start()

Starts the background image analysis. Until you call this function, no image analysis is performed.

IImageProcessingFactory

interface IImageProcessingFactory : IGenerateFactory

A factory which instantiates objects for image processing.

ImageSourceFromRGBAArray CreateImageSource(System.Func<Byte[]> getRGBAArray, System.Func<Int32> getWidth)

Creates an image source from a callback that returns an RGBA array and an image width. This is the fastest kind of image source for image analysis.

Parameters:

• getRGBAArray (System.Func<Byte[]>) – The callback which returns an array of RGBA values.
• getWidth (System.Func<Int32>) – The callback which returns the width of the image.

Returns:

An image source which can be used in image analysis.

ImageSourceFromTexture CreateImageSource(System.Func<Texture2D> getTexture2D)

Creates an image source from an in-memory texture.

Parameters:

• getTexture2D (System.Func<Texture2D>) – The callback which returns the texture.

Returns:

An image source which can be used in image analysis.

IColorInImageDetection CreateColorInImageDetection(IImageSource source)

Creates an object which can be used for detecting colors in an image. This functionality is useful for augmented reality, where you need to detect specific colored markers in an environment.

Parameters:

• source (Protogame.IImageSource) – The image source to detect color in.

Returns:

The color detection object.

Protogame.IPointInAnalysedImageDetection CreatePointInAnalysedImageDetection(IColorInImageDetection colorInImageDetection, Protogame.ISelectedColorHandle selectedColorHandle)

Creates an object which can be used for converting detected colors in an image into a series of discrete points.

Parameters:

• colorInImageDetection (Protogame.IColorInImageDetection) – The color detection object.
• selectedColorHandle (Protogame.ISelectedColorHandle) – The color to detect points with.

Returns:

IImageSource

interface IImageSource

Represents an image source for image processing.

System.Byte[] GetSourceAsBytes(ref int width, ref int height)

Parameters:

• (ref) width (int) –
• (ref) height (int) –

2D Platforming Utilities

Note

This documentation is a work-in-progress.

The platforming module provides utilities for handling collisions and movement in 2D platformer games.

Memory Pooling

Note

This documentation is a work-in-progress.

The pooling module provides classes for pooling data in games. Memory pooling in games is used to avoid expensive garbage collection and memory allocation operations, especially on mobile platforms.

IPool<T>

interface IPool<T> : IRawPool

A memory pool of objects.

Type Parameters:  

• T –

Protogame.T Get()

void Release(Protogame.T instance)

Parameters:

• instance (Protogame.T) –

void ReleaseAll()

IPoolManager

interface IPoolManager

The memory pool manager, which is used to create new pools of objects.

IPool<T> NewPool<T>(string name, int size, System.Action<T> resetAction)

Creates a new fixed-size memory pool of the specified size.

To use this method, the objects must have a public, parameter-less constructor. If they do not, you should use one of the variants of this method call that require for a factory function.

Type Parameters:  

• T – The type of objects to store in the memory pool.

Parameters:

• name (string) – The user-friendly name of the pool which can be viewed during memory debugging.
• size (int) – The size of the memory pool.
• resetAction (System.Action<T>) – An action which is called when the state of an object needs to be reset before reusing it.

Returns:

The memory pool.

IPool<T> NewPool<T>(string name, int size, System.Func<T> factoryFunc, System.Action<T> resetAction)

Creates a new fixed-size memory pool of the specified size.

Type Parameters:  

• T – The type of objects to store in the memory pool.

Parameters:

• name (string) – The user-friendly name of the pool which can be viewed during memory debugging.
• size (int) – The size of the memory pool.
• factoryFunc (System.Func<T>) – The factory function which allocates new objects for the pool.
• resetAction (System.Action<T>) – An action which is called when the state of an object needs to be reset before reusing it.

Returns:

The memory pool.

IPool<T> NewPool<T>(string name, int size, System.Func<T> factoryFunc, System.Action<T> resetAction, System.Action<T> newAction)

Creates a new fixed-size memory pool of the specified size.

Type Parameters:  

• T – The type of objects to store in the memory pool.

Parameters:

• name (string) – The user-friendly name of the pool which can be viewed during memory debugging.
• size (int) – The size of the memory pool.
• factoryFunc (System.Func<T>) – The factory function which allocates new objects for the pool.
• resetAction (System.Action<T>) – An action which is called when the state of an object needs to be reset before reusing it.
• newAction (System.Action<T>) – An action which is called before an object is given out for the first time.

Returns:

The memory pool.

IPool<T> NewScalingPool<T>(string name, int increment, System.Action<T> resetAction)

Creates a new scaling memory pool which can allocate and de-allocate blocks of objects as needed. This ensures that allocations of memory happen less frequently that they would otherwise for normal allocation and garbage collection.

To use this method, the objects must have a public, parameter-less constructor. If they do not, you should use one of the variants of this method call that require for a factory function.

Type Parameters:  

• T – The type of objects to store in the memory pool.

Parameters:

• name (string) – The user-friendly name of the pool which can be viewed during memory debugging.
• increment (int) – The size by which to increment the memory pool when more objects are needed, and the size by which to decrement the pool when less objects are needed.
• resetAction (System.Action<T>) – An action which is called when the state of an object needs to be reset before reusing it.

Returns:

The memory pool.

IPool<T> NewScalingPool<T>(string name, int increment, System.Func<T> factoryFunc, System.Action<T> resetAction)

Creates a new scaling memory pool which can allocate and de-allocate blocks of objects as needed. This ensures that allocations of memory happen less frequently that they would otherwise for normal allocation and garbage collection.

To use this method, the objects must have a public, parameter-less constructor. If they do not, you should use one of the variants of this method call that require for a factory function.

Type Parameters:  

• T – The type of objects to store in the memory pool.

Parameters:

• name (string) – The user-friendly name of the pool which can be viewed during memory debugging.
• increment (int) – The size by which to increment the memory pool when more objects are needed, and the size by which to decrement the pool when less objects are needed.
• factoryFunc (System.Func<T>) – The factory function which allocates new objects for the pool.
• resetAction (System.Action<T>) – An action which is called when the state of an object needs to be reset before reusing it.

Returns:

The memory pool.

IPool<T> NewScalingPool<T>(string name, int increment, System.Func<T> factoryFunc, System.Action<T> resetAction, System.Action<T> newAction)

Creates a new scaling memory pool which can allocate and de-allocate blocks of objects as needed. This ensures that allocations of memory happen less frequently that they would otherwise for normal allocation and garbage collection.

To use this method, the objects must have a public, parameter-less constructor. If they do not, you should use one of the variants of this method call that require for a factory function.

Type Parameters:  

• T – The type of objects to store in the memory pool.

Parameters:

• name (string) – The user-friendly name of the pool which can be viewed during memory debugging.
• increment (int) – The size by which to increment the memory pool when more objects are needed, and the size by which to decrement the pool when less objects are needed.
• factoryFunc (System.Func<T>) – The factory function which allocates new objects for the pool.
• resetAction (System.Action<T>) – An action which is called when the state of an object needs to be reset before reusing it.
• newAction (System.Action<T>) – An action which is called before an object is given out for the first time.

Returns:

The memory pool.

Protogame.IPool<T[]> NewArrayPool<T>(string name, int size, int arraySize, System.Action<T[]> resetAction)

Type Parameters:  

• T –

Parameters:

• name (string) –
• size (int) –
• arraySize (int) –
• resetAction (System.Action<T[]>) –

Protogame.IPool<T[]> NewScalingArrayPool<T>(string name, int increment, int arraySize, System.Action<T[]> resetAction)

Type Parameters:  

• T –

Parameters:

• name (string) –
• increment (int) –
• arraySize (int) –
• resetAction (System.Action<T[]>) –

Structure Utilities

Note

This documentation is a work-in-progress.

The structure utilities module provide various classes for organising data in games.

Noise Generation

Note

This documentation is a work-in-progress.

The noise generation module provides classes for procedurally generating noise, such as perlin noise maps.

Math Utilities

Protogame provides math utilities for various purposes.

CircumcentreSolver

class CircumcentreSolver : System.Object

Given four points in 3D space, solves for a sphere such that all four points lie on the sphere’s surface.

readonly System.Double[] Centre

The centre of the resulting sphere.

Value:The centre.

readonly double Radius

The radius of the resulting sphere.

Value:The radius.

readonly bool Valid

Whether the result was a valid sphere.

Value:The valid.

Extension Methods

Protogame provides extension methods for various built-in classes.

BoundingBoxExtensions

class BoundingBoxExtensions : System.Object

These extension methods assist with converting between bounding boxes and rectangles.

Protogame’s bounding box includes speed attributes, which the built-in MonoGame bounding box does not have.

public void CopyTo(Protogame.IBoundingBox boundingBox, Rectangle rectangle)

Copies the specified Protogame bounding box to the XNA rectangle.

Parameters:

• boundingBox (Protogame.IBoundingBox) – The Protogame bounding box to copy from.
• rectangle (Microsoft.Xna.Framework.Rectangle) – The XNA rectangle to copy to.

public void CopyTo(Rectangle rectangle, Protogame.IBoundingBox boundingBox)

Copies the specified XNA rectangle to the Protogame bounding box.

Parameters:

• rectangle (Microsoft.Xna.Framework.Rectangle) – The XNA rectangle to copy from.
• boundingBox (Protogame.IBoundingBox) – The Protogame bounding box to copy to.

public Protogame.IBoundingBox ToBoundingBox(Rectangle rectangle)

Converts the specified XNA rectangle to a Protogame bounding box.

Parameters:

• rectangle (Microsoft.Xna.Framework.Rectangle) – The XNA rectangle to convert.

Returns:

The T:Protogame.IBoundingBox.

public Protogame.IBoundingBox ToProtogame(BoundingBox boundingBox)

Converts the specified XNA bounding box to a Protogame bounding box.

Parameters:

• boundingBox (Microsoft.Xna.Framework.BoundingBox) – The XNA bounding box to convert.

Returns:

The T:Protogame.IBoundingBox.

public Rectangle ToRectangle(Protogame.IBoundingBox boundingBox)

Converts the specified Protogame bounding box to an XNA rectangle.

Parameters:

• boundingBox (Protogame.IBoundingBox) – The Protogame bounding box to convert.

Returns:

The T:Microsoft.Xna.Framework.Rectangle.

public BoundingBox ToXna(Protogame.IBoundingBox boundingBox)

Converts the specified Protogame bounding box to an XNA bounding box.

Parameters:

• boundingBox (Protogame.IBoundingBox) – The Protogame bounding box to convert.

Returns:

The T:Microsoft.Xna.Framework.BoundingBox.

KeyboardStateExtensions

class KeyboardStateExtensions : System.Object

Extensions for the XNA T:Microsoft.Xna.Framework.Input.KeyboardState class.

This provides state-aware functions for detecting changes in the keyboard state, without having to track the previous state in each object that wants to know about key presses.

public System.Nullable<KeyState> IsKeyChanged(KeyboardState state, System.Object obj, Keys key)

Detects whether the specified key has changed state.

Parameters:

• state (Microsoft.Xna.Framework.Input.KeyboardState) – The keyboard state to check.
• obj (System.Object) – The object for the unique check to be done against.
• key (Microsoft.Xna.Framework.Input.Keys) – The key to check.

Returns:

The state change of the key, or null if there’s no change.

public bool IsKeyPressed(KeyboardState state, System.Object obj, Keys key)

Parameters:

• state (Microsoft.Xna.Framework.Input.KeyboardState) –
• obj (System.Object) –
• key (Microsoft.Xna.Framework.Input.Keys) –

public bool TryConvertKeyboardInput(KeyboardState keyboard, KeyboardState oldKeyboard, ref char key, ref Keys special)

Parameters:

• keyboard (Microsoft.Xna.Framework.Input.KeyboardState) –
• oldKeyboard (Microsoft.Xna.Framework.Input.KeyboardState) –
• (ref) key (char) –
• (ref) special (Microsoft.Xna.Framework.Input.Keys) –

MouseStateExtensions

class MouseStateExtensions : System.Object

Extensions for the XNA T:Microsoft.Xna.Framework.Input.MouseState class.

This provides state-aware functions for detecting changes in the mouse state, without having to track the previous state in each object that wants to know about button presses.

public System.Nullable<ButtonState> LeftChanged(MouseState state, System.Object obj)

Detects whether or not the left mouse button has changed state.

Parameters:

• state (Microsoft.Xna.Framework.Input.MouseState) – The mouse state to check.
• obj (System.Object) – The object for the unique check to be done against.

Returns:

The state change of the left mouse button, or null if there’s no change.

public System.Nullable<ButtonState> LeftChanged(MouseState state, int hash)

Detects whether or not the left mouse button has changed state.

Parameters:

• state (Microsoft.Xna.Framework.Input.MouseState) – The mouse state to check.
• hash (int) – The unique hash code for the unique check to be done against.

Returns:

The state change of the left mouse button, or null if there’s no change.

public System.Nullable<ButtonState> MiddleChanged(MouseState state, System.Object obj)

Detects whether or not the middle mouse button has changed state.

Parameters:

• state (Microsoft.Xna.Framework.Input.MouseState) – The mouse state to check.
• obj (System.Object) – The object for the unique check to be done against.

Returns:

The state change of the middle mouse button, or null if there’s no change.

public System.Nullable<ButtonState> MiddleChanged(MouseState state, int hash)

Detects whether or not the middle mouse button has changed state.

Parameters:

• state (Microsoft.Xna.Framework.Input.MouseState) – The mouse state to check.
• hash (int) – The unique hash code for the unique check to be done against.

Returns:

The state change of the middle mouse button, or null if there’s no change.

public System.Nullable<ButtonState> RightChanged(MouseState state, System.Object obj)

Detects whether or not the right mouse button has changed state.

Parameters:

• state (Microsoft.Xna.Framework.Input.MouseState) – The mouse state to check.
• obj (System.Object) – The object for the unique check to be done against.

Returns:

The state change of the right mouse button, or null if there’s no change.

public System.Nullable<ButtonState> RightChanged(MouseState state, int hash)

Detects whether or not the right mouse button has changed state.

Parameters:

• state (Microsoft.Xna.Framework.Input.MouseState) – The mouse state to check.
• hash (int) – The unique hash code for the unique check to be done against.

Returns:

The state change of the right mouse button, or null if there’s no change.

public bool LeftPressed(MouseState state, System.Object obj)

Parameters:

• state (Microsoft.Xna.Framework.Input.MouseState) –
• obj (System.Object) –

public bool LeftPressed(MouseState state, int hash)

Parameters:

• state (Microsoft.Xna.Framework.Input.MouseState) –
• hash (int) –

public bool MiddlePressed(MouseState state, System.Object obj)

Parameters:

• state (Microsoft.Xna.Framework.Input.MouseState) –
• obj (System.Object) –

public bool MiddlePressed(MouseState state, int hash)

Parameters:

• state (Microsoft.Xna.Framework.Input.MouseState) –
• hash (int) –

public bool RightPressed(MouseState state, System.Object obj)

Parameters:

• state (Microsoft.Xna.Framework.Input.MouseState) –
• obj (System.Object) –

public bool RightPressed(MouseState state, int hash)

Parameters:

• state (Microsoft.Xna.Framework.Input.MouseState) –
• hash (int) –

RandomExtensions

class RandomExtensions : System.Object

These extension methods provide additional types of random number generation on the T:System.Random class provided by .NET

public double NextGuassian(System.Random rand, double min, double max)

Returns a new normally distributed number.

Parameters:

• rand (System.Random) – The random number generator.
• min (double) – The negative sigma 3 lower bound.
• max (double) – The positive sigma 3 upper bound.

Returns:

A random normally distributed number.

public double NextGuassianClamped(System.Random rand, double min, double max)

Returns a new normally distributed number, clamped to specified values.

Parameters:

• rand (System.Random) – The random number generator.
• min (double) – The lower bound.
• max (double) – The upper bound.

Returns:

A random normally distributed number, clamped to within sigma 3.

UtilityExtensions

class UtilityExtensions : System.Object

These utility extension methods don’t belong anywhere else.

public void Shuffle<T>(System.Collections.Generic.IList<T> list)

Shuffles the specified list in-place.

Type Parameters:  

• T –

Parameters:

• list (System.Collections.Generic.IList<T>) – The list to shuffle.

public Color ToPremultiplied(Color color)

Converts the color to it’s premultiplied format.

Parameters:

• color (Microsoft.Xna.Framework.Color) – The color to convert.

Returns:

The premultiplied T:Microsoft.Xna.Framework.Color.

VectorExtensions

class VectorExtensions : System.Object

These extension methods provide additional functionality to vector classes.

public Quaternion CreateLookQuaternion(Vector3 originalDirection, Vector3 targetDirection, Vector3 up)

Creates a Quaternion representing the rotation to look from the original direction vector to the target direction vector.

Parameters:

• originalDirection (Microsoft.Xna.Framework.Vector3) – The original direction vector.
• targetDirection (Microsoft.Xna.Framework.Vector3) – The target direction vector.
• up (Microsoft.Xna.Framework.Vector3) – The up vector.

Returns:

A quaternion representing the rotation.

Third-Party APIs

Protogame makes wide usage of third-party libraries to provide functionality, most notably MonoGame. Classes and methods in those third-party libraries are documented in the section below.

MonoGame Framework

MonoGame is an open source implementation of XNA, a low-level game engine written in C#. MonoGame is used in Protogame to provide abstraction of graphics rendering APIs, audio output and receiving input from hardware devices.

MonoGame also provides core classes, such as Vector3 and Matrix, which are used for almost all mathematical operations relating to games.

You will encounter these APIs frequently when using Protogame, either through use of the math APIs, or when you want to perform custom rendering.

Album

class Album : System.Object, System.IDisposable

readonly Artist Artist

readonly System.TimeSpan Duration

Gets the duration of the Album.

readonly Genre Genre

Gets the Genre of the Album.

readonly bool HasArt

Gets a value indicating whether the Album has associated album art.

readonly bool IsDisposed

Gets a value indicating whether the object is disposed.

readonly string Name

Gets the name of the Album.

readonly SongCollection Songs

Gets a SongCollection that contains the songs on the album.

public void Dispose()

Immediately releases the unmanaged resources used by this object.

public System.IO.Stream GetAlbumArt()

Returns the stream that contains the album art image data.

public System.IO.Stream GetThumbnail()

Returns the stream that contains the album thumbnail image data.

public string ToString()

Returns a String representation of this Album.

public int GetHashCode()

Gets the hash code for this instance.

AlbumCollection

class AlbumCollection : System.Object, System.IDisposable

readonly int Count

Gets the number of Album objects in the AlbumCollection.

readonly bool IsDisposed

Gets a value indicating whether the object is disposed.

readonly Album Item

public void Dispose()

Immediately releases the unmanaged resources used by this object.

Alpha8

struct Alpha8 : System.ValueType, Microsoft.Xna.Framework.Graphics.PackedVector.IPackedVector<Byte>, IPackedVector, System.IEquatable<Alpha8>

Packed vector type containing a single 8 bit normalized W values that is ranging from 0 to 1.

byte PackedValue

Gets and sets the packed value.

float ToAlpha()

Gets the packed vector in float format.

Returns:The packed vector in Vector3 format

bool Equals(System.Object obj)

Compares an object with the packed vector.

Parameters:

• obj (System.Object) – The object to compare.

Returns:

True if the object is equal to the packed vector.

bool Equals(Alpha8 other)

Compares another Alpha8 packed vector with the packed vector.

Parameters:

• other (Microsoft.Xna.Framework.Graphics.PackedVector.Alpha8) – The Alpha8 packed vector to compare.

Returns:

True if the packed vectors are equal.

string ToString()

Gets a string representation of the packed vector.

Returns:A string representation of the packed vector.

int GetHashCode()

Gets a hash code of the packed vector.

Returns:The hash code for the packed vector.

bool op_Equality(Alpha8 lhs, Alpha8 rhs)

Parameters:

• lhs (Microsoft.Xna.Framework.Graphics.PackedVector.Alpha8) –
• rhs (Microsoft.Xna.Framework.Graphics.PackedVector.Alpha8) –

bool op_Inequality(Alpha8 lhs, Alpha8 rhs)

Parameters:

• lhs (Microsoft.Xna.Framework.Graphics.PackedVector.Alpha8) –
• rhs (Microsoft.Xna.Framework.Graphics.PackedVector.Alpha8) –

AlphaTestEffect

class AlphaTestEffect : Effect, System.IDisposable, IEffectMatrices, IEffectFog

Built-in effect that supports alpha testing.

Matrix World

Gets or sets the world matrix.

Matrix View

Gets or sets the view matrix.

Matrix Projection

Gets or sets the projection matrix.

Vector3 DiffuseColor

Gets or sets the material diffuse color (range 0 to 1).

float Alpha

Gets or sets the material alpha.

bool FogEnabled

Gets or sets the fog enable flag.

float FogStart

Gets or sets the fog start distance.

float FogEnd

Gets or sets the fog end distance.

Vector3 FogColor

Gets or sets the fog color.

Texture2D Texture

Gets or sets the current texture.

bool VertexColorEnabled

Gets or sets whether vertex color is enabled.

CompareFunction AlphaFunction

Gets or sets the alpha compare function (default Greater).

int ReferenceAlpha

Gets or sets the reference alpha value (default 0).

public Effect Clone()

Creates a clone of the current AlphaTestEffect instance.

void OnApply()

Lazily computes derived parameter values immediately before applying the effect.

Artist

class Artist : System.Object, System.IDisposable

readonly AlbumCollection Albums

Gets the AlbumCollection for the Artist.

readonly bool IsDisposed

Gets a value indicating whether the object is disposed.

readonly string Name

Gets the name of the Artist.

readonly SongCollection Songs

Gets the SongCollection for the Artist.

public void Dispose()

Immediately releases the unmanaged resources used by this object.

public string ToString()

Returns a String representation of the Artist.

public int GetHashCode()

Gets the hash code for this instance.

AudioCategory

struct AudioCategory : System.ValueType, System.IEquatable<AudioCategory>

Provides functionality for manipulating multiple sounds at a time.

readonly string Name

Gets the category’s friendly name.

void AddSound(Microsoft.Xna.Framework.Audio.XactSound sound)

Parameters:

• sound (Microsoft.Xna.Framework.Audio.XactSound) –

int GetPlayingInstanceCount()

Microsoft.Xna.Framework.Audio.XactSound GetOldestInstance()

void Pause()

Pauses all associated sounds.

void Resume()

Resumes all associated paused sounds.

void Stop(AudioStopOptions options)

Stops all associated sounds.

Parameters:

• options (Microsoft.Xna.Framework.Audio.AudioStopOptions) –

void SetVolume(float volume)

Parameters:

• volume (float) –

bool op_Equality(AudioCategory first, AudioCategory second)

Determines whether two AudioCategory instances are equal.

Parameters:

• first (Microsoft.Xna.Framework.Audio.AudioCategory) – First AudioCategory instance to compare.
• second (Microsoft.Xna.Framework.Audio.AudioCategory) – Second AudioCategory instance to compare.

Returns:

true if the objects are equal or false if they aren’t.

bool op_Inequality(AudioCategory first, AudioCategory second)

Determines whether two AudioCategory instances are not equal.

Parameters:

• first (Microsoft.Xna.Framework.Audio.AudioCategory) – First AudioCategory instance to compare.
• second (Microsoft.Xna.Framework.Audio.AudioCategory) – Second AudioCategory instance to compare.

Returns:

true if the objects are not equal or false if they are.

bool Equals(AudioCategory other)

Determines whether two AudioCategory instances are equal.

Parameters:

• other (Microsoft.Xna.Framework.Audio.AudioCategory) – AudioCategory to compare with this instance.

Returns:

true if the objects are equal or false if they aren’t

bool Equals(System.Object obj)

Determines whether two AudioCategory instances are equal.

Parameters:

• obj (System.Object) – Object to compare with this instance.

Returns:

true if the objects are equal or false if they aren’t.

int GetHashCode()

Gets the hash code for this instance.

Returns:Hash code for this object.

string ToString()

Returns the name of this AudioCategory

Returns:Friendly name of the AudioCategory

AudioChannels

enum AudioChannels : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Represents how many channels are used in the audio data.

AudioChannels Mono

Single channel.

AudioChannels Stereo

Two channels.

AudioEmitter

class AudioEmitter : System.Object

Represents a 3D audio emitter. Used to simulate 3D audio effects.

float DopplerScale

Gets or sets a scale applied to the Doppler effect between the AudioEmitter and an AudioListener.

Vector3 Forward

Gets or sets the emitter’s forward vector.

Vector3 Position

Gets or sets the position of this emitter.

Vector3 Up

Gets or sets the emitter’s Up vector.

Vector3 Velocity

Gets or sets the emitter’s velocity vector.

AudioEngine

class AudioEngine : System.Object, System.IDisposable

Class used to create and manipulate code audio objects.

int ContentVersion

The current content version.

readonly bool IsDisposed

Is true if the AudioEngine has been disposed.

Microsoft.Xna.Framework.Audio.AudioCategory[] get_Categories()

Microsoft.Xna.Framework.Audio.RpcVariable[] CreateCueVariables()

System.IO.Stream OpenStream(string filePath)

Parameters:

• filePath (string) –

int GetRpcIndex(uint fileOffset)

Parameters:

• fileOffset (uint) –

public void Update()

Performs periodic work required by the audio engine.

public AudioCategory GetCategory(string name)

Returns an audio category by name.

Parameters:

• name (string) – Friendly name of the category to get.

Returns:

The AudioCategory with a matching name. Throws an exception if not found.

public float GetGlobalVariable(string name)

Gets the value of a global variable.

Parameters:

• name (string) – Friendly name of the variable.

Returns:

float value of the queried variable.

float GetGlobalVariable(int index)

Parameters:

• index (int) –

public void SetGlobalVariable(string name, float value)

Sets the value of a global variable.

Parameters:

• name (string) – Friendly name of the variable.
• value (float) – Value of the global variable.

public void add_Disposing(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_Disposing(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void Dispose()

Disposes the AudioEngine.

AudioListener

class AudioListener : System.Object

Represents a 3D audio listener. Used when simulating 3D Audio.

Vector3 Forward

Gets or sets the listener’s forward vector.

Vector3 Position

Gets or sets the listener’s position.

Vector3 Up

Gets or sets the listener’s up vector..

Vector3 Velocity

Gets or sets the listener’s velocity vector.

AudioStopOptions

enum AudioStopOptions : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Controls how Cue objects should cease playback when told to stop.

AudioStopOptions AsAuthored

Stop normally, playing any pending release phases or transitions.

AudioStopOptions Immediate

Immediately stops the cue, ignoring any pending release phases or transitions.

BasicEffect

class BasicEffect : Effect, System.IDisposable, IEffectMatrices, IEffectLights, IEffectFog

Built-in effect that supports optional texturing, vertex coloring, fog, and lighting.

Matrix World

Gets or sets the world matrix.

Matrix View

Gets or sets the view matrix.

Matrix Projection

Gets or sets the projection matrix.

Vector3 DiffuseColor

Gets or sets the material diffuse color (range 0 to 1).

Vector3 EmissiveColor

Gets or sets the material emissive color (range 0 to 1).

Vector3 SpecularColor

Gets or sets the material specular color (range 0 to 1).

float SpecularPower

Gets or sets the material specular power.

float Alpha

Gets or sets the material alpha.

bool LightingEnabled

bool PreferPerPixelLighting

Gets or sets the per-pixel lighting prefer flag.

Vector3 AmbientLightColor

readonly DirectionalLight DirectionalLight0

readonly DirectionalLight DirectionalLight1

readonly DirectionalLight DirectionalLight2

bool FogEnabled

float FogStart

float FogEnd

Vector3 FogColor

bool TextureEnabled

Gets or sets whether texturing is enabled.

Texture2D Texture

Gets or sets the current texture.

bool VertexColorEnabled

Gets or sets whether vertex color is enabled.

public Effect Clone()

Creates a clone of the current BasicEffect instance.

public void EnableDefaultLighting()

void OnApply()

Lazily computes derived parameter values immediately before applying the effect.

Bgr565

struct Bgr565 : System.ValueType, Microsoft.Xna.Framework.Graphics.PackedVector.IPackedVector<UInt16>, IPackedVector, System.IEquatable<Bgr565>

Packed vector type containing unsigned normalized values ranging from 0 to 1. The x and z components use 5 bits, and the y component uses 6 bits.

ushort PackedValue

Gets and sets the packed value.

Vector3 ToVector3()

Gets the packed vector in Vector3 format.

Returns:The packed vector in Vector3 format

bool Equals(System.Object obj)

Compares an object with the packed vector.

Parameters:

• obj (System.Object) – The object to compare.

Returns:

true if the object is equal to the packed vector.

bool Equals(Bgr565 other)

Compares another Bgr565 packed vector with the packed vector.

Parameters:

• other (Microsoft.Xna.Framework.Graphics.PackedVector.Bgr565) – The Bgr565 packed vector to compare.

Returns:

true if the packed vectors are equal.

string ToString()

Gets a string representation of the packed vector.

Returns:A string representation of the packed vector.

int GetHashCode()

Gets a hash code of the packed vector.

Returns:The hash code for the packed vector.

bool op_Equality(Bgr565 lhs, Bgr565 rhs)

Parameters:

• lhs (Microsoft.Xna.Framework.Graphics.PackedVector.Bgr565) –
• rhs (Microsoft.Xna.Framework.Graphics.PackedVector.Bgr565) –

bool op_Inequality(Bgr565 lhs, Bgr565 rhs)

Parameters:

• lhs (Microsoft.Xna.Framework.Graphics.PackedVector.Bgr565) –
• rhs (Microsoft.Xna.Framework.Graphics.PackedVector.Bgr565) –

Bgra4444

struct Bgra4444 : System.ValueType, Microsoft.Xna.Framework.Graphics.PackedVector.IPackedVector<UInt16>, IPackedVector, System.IEquatable<Bgra4444>

Packed vector type containing unsigned normalized values, ranging from 0 to 1, using 4 bits each for x, y, z, and w.

ushort PackedValue

Gets and sets the packed value.

Vector4 ToVector4()

Gets the packed vector in Vector4 format.

Returns:The packed vector in Vector4 format

bool Equals(System.Object obj)

Compares an object with the packed vector.

Parameters:

• obj (System.Object) – The object to compare.

Returns:

true if the object is equal to the packed vector.

bool Equals(Bgra4444 other)

Compares another Bgra4444 packed vector with the packed vector.

Parameters:

• other (Microsoft.Xna.Framework.Graphics.PackedVector.Bgra4444) – The Bgra4444 packed vector to compare.

Returns:

true if the packed vectors are equal.

string ToString()

Gets a string representation of the packed vector.

Returns:A string representation of the packed vector.

int GetHashCode()

Gets a hash code of the packed vector.

Returns:The hash code for the packed vector.

bool op_Equality(Bgra4444 lhs, Bgra4444 rhs)

Parameters:

• lhs (Microsoft.Xna.Framework.Graphics.PackedVector.Bgra4444) –
• rhs (Microsoft.Xna.Framework.Graphics.PackedVector.Bgra4444) –

bool op_Inequality(Bgra4444 lhs, Bgra4444 rhs)

Parameters:

• lhs (Microsoft.Xna.Framework.Graphics.PackedVector.Bgra4444) –
• rhs (Microsoft.Xna.Framework.Graphics.PackedVector.Bgra4444) –

Bgra5551

struct Bgra5551 : System.ValueType, Microsoft.Xna.Framework.Graphics.PackedVector.IPackedVector<UInt16>, IPackedVector, System.IEquatable<Bgra5551>

Packed vector type containing unsigned normalized values ranging from 0 to 1. The x , y and z components use 5 bits, and the w component uses 1 bit.

ushort PackedValue

Gets and sets the packed value.

Vector4 ToVector4()

Gets the packed vector in Vector4 format.

Returns:The packed vector in Vector4 format

bool Equals(System.Object obj)

Compares an object with the packed vector.

Parameters:

• obj (System.Object) – The object to compare.

Returns:

True if the object is equal to the packed vector.

bool Equals(Bgra5551 other)

Compares another Bgra5551 packed vector with the packed vector.

Parameters:

• other (Microsoft.Xna.Framework.Graphics.PackedVector.Bgra5551) – The Bgra5551 packed vector to compare.

Returns:

True if the packed vectors are equal.

string ToString()

Gets a string representation of the packed vector.

Returns:A string representation of the packed vector.

int GetHashCode()

Gets a hash code of the packed vector.

Returns:The hash code for the packed vector.

bool op_Equality(Bgra5551 lhs, Bgra5551 rhs)

Parameters:

• lhs (Microsoft.Xna.Framework.Graphics.PackedVector.Bgra5551) –
• rhs (Microsoft.Xna.Framework.Graphics.PackedVector.Bgra5551) –

bool op_Inequality(Bgra5551 lhs, Bgra5551 rhs)

Parameters:

• lhs (Microsoft.Xna.Framework.Graphics.PackedVector.Bgra5551) –
• rhs (Microsoft.Xna.Framework.Graphics.PackedVector.Bgra5551) –

Blend

enum Blend : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines a blend mode.

Blend One

Each component of the color is multiplied by {1, 1, 1, 1}.

Blend Zero

Each component of the color is multiplied by {0, 0, 0, 0}.

Blend SourceColor

Each component of the color is multiplied by the source color. {Rs, Gs, Bs, As}, where Rs, Gs, Bs, As are color source values.

Blend InverseSourceColor

Each component of the color is multiplied by the inverse of the source color.

{1 − Rs, 1 − Gs, 1 − Bs, 1 − As}, where Rs, Gs, Bs, As are color source values.

Blend SourceAlpha

Each component of the color is multiplied by the alpha value of the source. {As, As, As, As}, where As is the source alpha value.

Blend InverseSourceAlpha

Each component of the color is multiplied by the inverse of the alpha value of the source. {1 − As, 1 − As, 1 − As, 1 − As}, where As is the source alpha value.

Blend DestinationColor

Each component color is multiplied by the destination color. {Rd, Gd, Bd, Ad}, where Rd, Gd, Bd, Ad are color destination values.

Blend InverseDestinationColor

Each component of the color is multiplied by the inversed destination color. {1 − Rd, 1 − Gd, 1 − Bd, 1 − Ad}, where Rd, Gd, Bd, Ad are color destination values.

Blend DestinationAlpha

Each component of the color is multiplied by the alpha value of the destination. {Ad, Ad, Ad, Ad}, where Ad is the destination alpha value.

Blend InverseDestinationAlpha

Each component of the color is multiplied by the inversed alpha value of the destination. {1 − Ad, 1 − Ad, 1 − Ad, 1 − Ad}, where Ad is the destination alpha value.

Blend BlendFactor

Each component of the color is multiplied by a constant in the P:Microsoft.Xna.Framework.Graphics.GraphicsDevice.BlendFactor.

Blend InverseBlendFactor

Each component of the color is multiplied by a inversed constant in the P:Microsoft.Xna.Framework.Graphics.GraphicsDevice.BlendFactor.

Blend SourceAlphaSaturation

Each component of the color is multiplied by either the alpha of the source color, or the inverse of the alpha of the source color, whichever is greater. {f, f, f, 1}, where f = min(As, 1 − As), where As is the source alpha value.

BlendFunction

enum BlendFunction : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines a function for color blending.

BlendFunction Add

The function will adds destination to the source. (srcColor * srcBlend) + (destColor * destBlend)

BlendFunction Subtract

The function will subtracts destination from source. (srcColor * srcBlend) − (destColor * destBlend)

BlendFunction ReverseSubtract

The function will subtracts source from destination. (destColor * destBlend) - (srcColor * srcBlend)

BlendFunction Min

The function will extracts minimum of the source and destination. min((srcColor * srcBlend),(destColor * destBlend))

BlendFunction Max

The function will extracts maximum of the source and destination. max((srcColor * srcBlend),(destColor * destBlend))

BlendState

class BlendState : GraphicsResource, System.IDisposable

BlendState Additive

BlendState AlphaBlend

BlendState NonPremultiplied

BlendState Opaque

readonly TargetBlendState Item

BlendFunction AlphaBlendFunction

Blend AlphaDestinationBlend

Blend AlphaSourceBlend

BlendFunction ColorBlendFunction

Blend ColorDestinationBlend

Blend ColorSourceBlend

ColorWriteChannels ColorWriteChannels

ColorWriteChannels ColorWriteChannels1

ColorWriteChannels ColorWriteChannels2

ColorWriteChannels ColorWriteChannels3

Color BlendFactor

The color used as blend factor when alpha blending.

int MultiSampleMask

bool IndependentBlendEnable

Enables use of the per-target blend states.

void BindToGraphicsDevice(GraphicsDevice device)

Parameters:

• device (Microsoft.Xna.Framework.Graphics.GraphicsDevice) –

void ThrowIfBound()

BlendState Clone()

void GraphicsDeviceResetting()

SharpDX.Direct3D11.BlendState GetDxState(GraphicsDevice device)

Parameters:

• device (Microsoft.Xna.Framework.Graphics.GraphicsDevice) –

BoundingBox

struct BoundingBox : System.ValueType, System.IEquatable<BoundingBox>

Vector3 Min

Vector3 Max

int CornerCount

ContainmentType Contains(BoundingBox box)

Parameters:

• box (Microsoft.Xna.Framework.BoundingBox) –

void Contains(ref BoundingBox box, ref ContainmentType result)

Parameters:

• (ref) box (Microsoft.Xna.Framework.BoundingBox) –
• (ref) result (Microsoft.Xna.Framework.ContainmentType) –

ContainmentType Contains(BoundingFrustum frustum)

Parameters:

• frustum (Microsoft.Xna.Framework.BoundingFrustum) –

ContainmentType Contains(BoundingSphere sphere)

Parameters:

• sphere (Microsoft.Xna.Framework.BoundingSphere) –

void Contains(ref BoundingSphere sphere, ref ContainmentType result)

Parameters:

• (ref) sphere (Microsoft.Xna.Framework.BoundingSphere) –
• (ref) result (Microsoft.Xna.Framework.ContainmentType) –

ContainmentType Contains(Vector3 point)

Parameters:

• point (Microsoft.Xna.Framework.Vector3) –

void Contains(ref Vector3 point, ref ContainmentType result)

Parameters:

• (ref) point (Microsoft.Xna.Framework.Vector3) –
• (ref) result (Microsoft.Xna.Framework.ContainmentType) –

BoundingBox CreateFromPoints(System.Collections.Generic.IEnumerable<Vector3> points)

Create a bounding box from the given list of points.

Parameters:

• points (System.Collections.Generic.IEnumerable<Vector3>) – The list of Vector3 instances defining the point cloud to bound

Returns:

A bounding box that encapsulates the given point cloud.

BoundingBox CreateFromSphere(BoundingSphere sphere)

Parameters:

• sphere (Microsoft.Xna.Framework.BoundingSphere) –

void CreateFromSphere(ref BoundingSphere sphere, ref BoundingBox result)

Parameters:

• (ref) sphere (Microsoft.Xna.Framework.BoundingSphere) –
• (ref) result (Microsoft.Xna.Framework.BoundingBox) –

BoundingBox CreateMerged(BoundingBox original, BoundingBox additional)

Parameters:

• original (Microsoft.Xna.Framework.BoundingBox) –
• additional (Microsoft.Xna.Framework.BoundingBox) –

void CreateMerged(ref BoundingBox original, ref BoundingBox additional, ref BoundingBox result)

Parameters:

• (ref) original (Microsoft.Xna.Framework.BoundingBox) –
• (ref) additional (Microsoft.Xna.Framework.BoundingBox) –
• (ref) result (Microsoft.Xna.Framework.BoundingBox) –

bool Equals(BoundingBox other)

Parameters:

• other (Microsoft.Xna.Framework.BoundingBox) –

bool Equals(System.Object obj)

Parameters:

• obj (System.Object) –

Microsoft.Xna.Framework.Vector3[] GetCorners()

void GetCorners(Microsoft.Xna.Framework.Vector3[] corners)

Parameters:

• corners (Microsoft.Xna.Framework.Vector3[]) –

int GetHashCode()

bool Intersects(BoundingBox box)

Parameters:

• box (Microsoft.Xna.Framework.BoundingBox) –

void Intersects(ref BoundingBox box, ref bool result)

Parameters:

• (ref) box (Microsoft.Xna.Framework.BoundingBox) –
• (ref) result (bool) –

bool Intersects(BoundingFrustum frustum)

Parameters:

• frustum (Microsoft.Xna.Framework.BoundingFrustum) –

bool Intersects(BoundingSphere sphere)

Parameters:

• sphere (Microsoft.Xna.Framework.BoundingSphere) –

void Intersects(ref BoundingSphere sphere, ref bool result)

Parameters:

• (ref) sphere (Microsoft.Xna.Framework.BoundingSphere) –
• (ref) result (bool) –

PlaneIntersectionType Intersects(Plane plane)

Parameters:

• plane (Microsoft.Xna.Framework.Plane) –

void Intersects(ref Plane plane, ref PlaneIntersectionType result)

Parameters:

• (ref) plane (Microsoft.Xna.Framework.Plane) –
• (ref) result (Microsoft.Xna.Framework.PlaneIntersectionType) –

System.Nullable<Single> Intersects(Ray ray)

Parameters:

• ray (Microsoft.Xna.Framework.Ray) –

void Intersects(ref Ray ray, ref System.Nullable<Single> result)

Parameters:

• (ref) ray (Microsoft.Xna.Framework.Ray) –
• (ref) result (System.Nullable<Single>) –

bool op_Equality(BoundingBox a, BoundingBox b)

Parameters:

• a (Microsoft.Xna.Framework.BoundingBox) –
• b (Microsoft.Xna.Framework.BoundingBox) –

bool op_Inequality(BoundingBox a, BoundingBox b)

Parameters:

• a (Microsoft.Xna.Framework.BoundingBox) –
• b (Microsoft.Xna.Framework.BoundingBox) –

string get_DebugDisplayString()

string ToString()

BoundingFrustum

class BoundingFrustum : System.Object, System.IEquatable<BoundingFrustum>

Defines a viewing frustum for intersection operations.

int PlaneCount

The number of planes in the frustum.

int CornerCount

The number of corner points in the frustum.

Matrix Matrix

Gets or sets the P:Microsoft.Xna.Framework.BoundingFrustum.Matrix of the frustum.

readonly Plane Near

Gets the near plane of the frustum.

readonly Plane Far

Gets the far plane of the frustum.

readonly Plane Left

Gets the left plane of the frustum.

readonly Plane Right

Gets the right plane of the frustum.

readonly Plane Top

Gets the top plane of the frustum.

readonly Plane Bottom

Gets the bottom plane of the frustum.

string get_DebugDisplayString()

public bool op_Equality(BoundingFrustum a, BoundingFrustum b)

Compares whether two T:Microsoft.Xna.Framework.BoundingFrustum instances are equal.

Parameters:

• a (Microsoft.Xna.Framework.BoundingFrustum) – T:Microsoft.Xna.Framework.BoundingFrustum instance on the left of the equal sign.
• b (Microsoft.Xna.Framework.BoundingFrustum) – T:Microsoft.Xna.Framework.BoundingFrustum instance on the right of the equal sign.

Returns:

true if the instances are equal; false otherwise.

public bool op_Inequality(BoundingFrustum a, BoundingFrustum b)

Compares whether two T:Microsoft.Xna.Framework.BoundingFrustum instances are not equal.

Parameters:

• a (Microsoft.Xna.Framework.BoundingFrustum) – T:Microsoft.Xna.Framework.BoundingFrustum instance on the left of the not equal sign.
• b (Microsoft.Xna.Framework.BoundingFrustum) – T:Microsoft.Xna.Framework.BoundingFrustum instance on the right of the not equal sign.

Returns:

true if the instances are not equal; false otherwise.

public ContainmentType Contains(BoundingBox box)

Containment test between this T:Microsoft.Xna.Framework.BoundingFrustum and specified T:Microsoft.Xna.Framework.BoundingBox.

Parameters:

• box (Microsoft.Xna.Framework.BoundingBox) – A T:Microsoft.Xna.Framework.BoundingBox for testing.

Returns:

Result of testing for containment between this T:Microsoft.Xna.Framework.BoundingFrustum and specified T:Microsoft.Xna.Framework.BoundingBox.

public void Contains(ref BoundingBox box, ref ContainmentType result)

Parameters:

• (ref) box (Microsoft.Xna.Framework.BoundingBox) –
• (ref) result (Microsoft.Xna.Framework.ContainmentType) –

public ContainmentType Contains(BoundingFrustum frustum)

Containment test between this T:Microsoft.Xna.Framework.BoundingFrustum and specified T:Microsoft.Xna.Framework.BoundingFrustum.

Parameters:

• frustum (Microsoft.Xna.Framework.BoundingFrustum) – A T:Microsoft.Xna.Framework.BoundingFrustum for testing.

Returns:

Result of testing for containment between this T:Microsoft.Xna.Framework.BoundingFrustum and specified T:Microsoft.Xna.Framework.BoundingFrustum.

public ContainmentType Contains(BoundingSphere sphere)

Containment test between this T:Microsoft.Xna.Framework.BoundingFrustum and specified T:Microsoft.Xna.Framework.BoundingSphere.

Parameters:

• sphere (Microsoft.Xna.Framework.BoundingSphere) – A T:Microsoft.Xna.Framework.BoundingSphere for testing.

Returns:

Result of testing for containment between this T:Microsoft.Xna.Framework.BoundingFrustum and specified T:Microsoft.Xna.Framework.BoundingSphere.

public void Contains(ref BoundingSphere sphere, ref ContainmentType result)

Parameters:

• (ref) sphere (Microsoft.Xna.Framework.BoundingSphere) –
• (ref) result (Microsoft.Xna.Framework.ContainmentType) –

public ContainmentType Contains(Vector3 point)

Containment test between this T:Microsoft.Xna.Framework.BoundingFrustum and specified T:Microsoft.Xna.Framework.Vector3.

Parameters:

• point (Microsoft.Xna.Framework.Vector3) – A T:Microsoft.Xna.Framework.Vector3 for testing.

Returns:

Result of testing for containment between this T:Microsoft.Xna.Framework.BoundingFrustum and specified T:Microsoft.Xna.Framework.Vector3.

public void Contains(ref Vector3 point, ref ContainmentType result)

Parameters:

• (ref) point (Microsoft.Xna.Framework.Vector3) –
• (ref) result (Microsoft.Xna.Framework.ContainmentType) –

public bool Equals(BoundingFrustum other)

Compares whether current instance is equal to specified T:Microsoft.Xna.Framework.BoundingFrustum.

Parameters:

• other (Microsoft.Xna.Framework.BoundingFrustum) – The T:Microsoft.Xna.Framework.BoundingFrustum to compare.

Returns:

true if the instances are equal; false otherwise.

public bool Equals(System.Object obj)

Compares whether current instance is equal to specified T:Microsoft.Xna.Framework.BoundingFrustum.

Parameters:

• obj (System.Object) – The T:System.Object to compare.

Returns:

true if the instances are equal; false otherwise.

public Microsoft.Xna.Framework.Vector3[] GetCorners()

Returns a copy of internal corners array.

Returns:The array of corners.

public void GetCorners(Microsoft.Xna.Framework.Vector3[] corners)

Returns a copy of internal corners array.

Parameters:

• corners (Microsoft.Xna.Framework.Vector3[]) – The array which values will be replaced to corner values of this instance. It must have size of F:Microsoft.Xna.Framework.BoundingFrustum.CornerCount.

public int GetHashCode()

Gets the hash code of this T:Microsoft.Xna.Framework.BoundingFrustum.

Returns:Hash code of this T:Microsoft.Xna.Framework.BoundingFrustum.

public bool Intersects(BoundingBox box)

Gets whether or not a specified T:Microsoft.Xna.Framework.BoundingBox intersects with this T:Microsoft.Xna.Framework.BoundingFrustum.

Parameters:

• box (Microsoft.Xna.Framework.BoundingBox) – A T:Microsoft.Xna.Framework.BoundingBox for intersection test.

Returns:

true if specified T:Microsoft.Xna.Framework.BoundingBox intersects with this T:Microsoft.Xna.Framework.BoundingFrustum; false otherwise.

public void Intersects(ref BoundingBox box, ref bool result)

Parameters:

• (ref) box (Microsoft.Xna.Framework.BoundingBox) –
• (ref) result (bool) –

public bool Intersects(BoundingFrustum frustum)

Gets whether or not a specified T:Microsoft.Xna.Framework.BoundingFrustum intersects with this T:Microsoft.Xna.Framework.BoundingFrustum.

Parameters:

• frustum (Microsoft.Xna.Framework.BoundingFrustum) – An other T:Microsoft.Xna.Framework.BoundingFrustum for intersection test.

Returns:

true if other T:Microsoft.Xna.Framework.BoundingFrustum intersects with this T:Microsoft.Xna.Framework.BoundingFrustum; false otherwise.

public bool Intersects(BoundingSphere sphere)

Gets whether or not a specified T:Microsoft.Xna.Framework.BoundingSphere intersects with this T:Microsoft.Xna.Framework.BoundingFrustum.

Parameters:

• sphere (Microsoft.Xna.Framework.BoundingSphere) – A T:Microsoft.Xna.Framework.BoundingSphere for intersection test.

Returns:

true if specified T:Microsoft.Xna.Framework.BoundingSphere intersects with this T:Microsoft.Xna.Framework.BoundingFrustum; false otherwise.

public void Intersects(ref BoundingSphere sphere, ref bool result)

Parameters:

• (ref) sphere (Microsoft.Xna.Framework.BoundingSphere) –
• (ref) result (bool) –

public PlaneIntersectionType Intersects(Plane plane)

Gets type of intersection between specified T:Microsoft.Xna.Framework.Plane and this T:Microsoft.Xna.Framework.BoundingFrustum.

Parameters:

• plane (Microsoft.Xna.Framework.Plane) – A T:Microsoft.Xna.Framework.Plane for intersection test.

Returns:

A plane intersection type.

public void Intersects(ref Plane plane, ref PlaneIntersectionType result)

Parameters:

• (ref) plane (Microsoft.Xna.Framework.Plane) –
• (ref) result (Microsoft.Xna.Framework.PlaneIntersectionType) –

public System.Nullable<Single> Intersects(Ray ray)

Gets the distance of intersection of T:Microsoft.Xna.Framework.Ray and this T:Microsoft.Xna.Framework.BoundingFrustum or null if no intersection happens.

Parameters:

• ray (Microsoft.Xna.Framework.Ray) – A T:Microsoft.Xna.Framework.Ray for intersection test.

Returns:

Distance at which ray intersects with this T:Microsoft.Xna.Framework.BoundingFrustum or null if no intersection happens.

public void Intersects(ref Ray ray, ref System.Nullable<Single> result)

Parameters:

• (ref) ray (Microsoft.Xna.Framework.Ray) –
• (ref) result (System.Nullable<Single>) –

public string ToString()

Returns a T:System.String representation of this T:Microsoft.Xna.Framework.BoundingFrustum in the format: {Near:[nearPlane] Far:[farPlane] Left:[leftPlane] Right:[rightPlane] Top:[topPlane] Bottom:[bottomPlane]}

Returns:T:System.String representation of this T:Microsoft.Xna.Framework.BoundingFrustum.

BoundingSphere

struct BoundingSphere : System.ValueType, System.IEquatable<BoundingSphere>

Describes a sphere in 3D-space for bounding operations.

Vector3 Center

The sphere center.

float Radius

The sphere radius.

string get_DebugDisplayString()

ContainmentType Contains(BoundingBox box)

Test if a bounding box is fully inside, outside, or just intersecting the sphere.

Parameters:

• box (Microsoft.Xna.Framework.BoundingBox) – The box for testing.

Returns:

The containment type.

void Contains(ref BoundingBox box, ref ContainmentType result)

Parameters:

• (ref) box (Microsoft.Xna.Framework.BoundingBox) –
• (ref) result (Microsoft.Xna.Framework.ContainmentType) –

ContainmentType Contains(BoundingFrustum frustum)

Test if a frustum is fully inside, outside, or just intersecting the sphere.

Parameters:

• frustum (Microsoft.Xna.Framework.BoundingFrustum) – The frustum for testing.

Returns:

The containment type.

void Contains(ref BoundingFrustum frustum, ref ContainmentType result)

Parameters:

• (ref) frustum (Microsoft.Xna.Framework.BoundingFrustum) –
• (ref) result (Microsoft.Xna.Framework.ContainmentType) –

ContainmentType Contains(BoundingSphere sphere)

Test if a sphere is fully inside, outside, or just intersecting the sphere.

Parameters:

• sphere (Microsoft.Xna.Framework.BoundingSphere) – The other sphere for testing.

Returns:

The containment type.

void Contains(ref BoundingSphere sphere, ref ContainmentType result)

Parameters:

• (ref) sphere (Microsoft.Xna.Framework.BoundingSphere) –
• (ref) result (Microsoft.Xna.Framework.ContainmentType) –

ContainmentType Contains(Vector3 point)

Test if a point is fully inside, outside, or just intersecting the sphere.

Parameters:

• point (Microsoft.Xna.Framework.Vector3) – The vector in 3D-space for testing.

Returns:

The containment type.

void Contains(ref Vector3 point, ref ContainmentType result)

Parameters:

• (ref) point (Microsoft.Xna.Framework.Vector3) –
• (ref) result (Microsoft.Xna.Framework.ContainmentType) –

BoundingSphere CreateFromBoundingBox(BoundingBox box)

Creates the smallest T:Microsoft.Xna.Framework.BoundingSphere that can contain a specified T:Microsoft.Xna.Framework.BoundingBox.

Parameters:

• box (Microsoft.Xna.Framework.BoundingBox) – The box to create the sphere from.

Returns:

The new T:Microsoft.Xna.Framework.BoundingSphere.

void CreateFromBoundingBox(ref BoundingBox box, ref BoundingSphere result)

Parameters:

• (ref) box (Microsoft.Xna.Framework.BoundingBox) –
• (ref) result (Microsoft.Xna.Framework.BoundingSphere) –

BoundingSphere CreateFromFrustum(BoundingFrustum frustum)

Creates the smallest T:Microsoft.Xna.Framework.BoundingSphere that can contain a specified T:Microsoft.Xna.Framework.BoundingFrustum.

Parameters:

• frustum (Microsoft.Xna.Framework.BoundingFrustum) – The frustum to create the sphere from.

Returns:

The new T:Microsoft.Xna.Framework.BoundingSphere.

BoundingSphere CreateFromPoints(System.Collections.Generic.IEnumerable<Vector3> points)

Creates the smallest T:Microsoft.Xna.Framework.BoundingSphere that can contain a specified list of points in 3D-space.

Parameters:

• points (System.Collections.Generic.IEnumerable<Vector3>) – List of point to create the sphere from.

Returns:

The new T:Microsoft.Xna.Framework.BoundingSphere.

BoundingSphere CreateMerged(BoundingSphere original, BoundingSphere additional)

Creates the smallest T:Microsoft.Xna.Framework.BoundingSphere that can contain two spheres.

Parameters:

• original (Microsoft.Xna.Framework.BoundingSphere) – First sphere.
• additional (Microsoft.Xna.Framework.BoundingSphere) – Second sphere.

Returns:

The new T:Microsoft.Xna.Framework.BoundingSphere.

void CreateMerged(ref BoundingSphere original, ref BoundingSphere additional, ref BoundingSphere result)

Parameters:

• (ref) original (Microsoft.Xna.Framework.BoundingSphere) –
• (ref) additional (Microsoft.Xna.Framework.BoundingSphere) –
• (ref) result (Microsoft.Xna.Framework.BoundingSphere) –

bool Equals(BoundingSphere other)

Compares whether current instance is equal to specified T:Microsoft.Xna.Framework.BoundingSphere.

Parameters:

• other (Microsoft.Xna.Framework.BoundingSphere) – The T:Microsoft.Xna.Framework.BoundingSphere to compare.

Returns:

true if the instances are equal; false otherwise.

bool Equals(System.Object obj)

Compares whether current instance is equal to specified T:System.Object.

Parameters:

• obj (System.Object) – The T:System.Object to compare.

Returns:

true if the instances are equal; false otherwise.

int GetHashCode()

Gets the hash code of this T:Microsoft.Xna.Framework.BoundingSphere.

Returns:Hash code of this T:Microsoft.Xna.Framework.BoundingSphere.

bool Intersects(BoundingBox box)

Gets whether or not a specified T:Microsoft.Xna.Framework.BoundingBox intersects with this sphere.

Parameters:

• box (Microsoft.Xna.Framework.BoundingBox) – The box for testing.

Returns:

true if T:Microsoft.Xna.Framework.BoundingBox intersects with this sphere; false otherwise.

void Intersects(ref BoundingBox box, ref bool result)

Parameters:

• (ref) box (Microsoft.Xna.Framework.BoundingBox) –
• (ref) result (bool) –

bool Intersects(BoundingSphere sphere)

Gets whether or not the other T:Microsoft.Xna.Framework.BoundingSphere intersects with this sphere.

Parameters:

• sphere (Microsoft.Xna.Framework.BoundingSphere) – The other sphere for testing.

Returns:

true if other T:Microsoft.Xna.Framework.BoundingSphere intersects with this sphere; false otherwise.

void Intersects(ref BoundingSphere sphere, ref bool result)

Parameters:

• (ref) sphere (Microsoft.Xna.Framework.BoundingSphere) –
• (ref) result (bool) –

PlaneIntersectionType Intersects(Plane plane)

Gets whether or not a specified T:Microsoft.Xna.Framework.Plane intersects with this sphere.

Parameters:

• plane (Microsoft.Xna.Framework.Plane) – The plane for testing.

Returns:

Type of intersection.

void Intersects(ref Plane plane, ref PlaneIntersectionType result)

Parameters:

• (ref) plane (Microsoft.Xna.Framework.Plane) –
• (ref) result (Microsoft.Xna.Framework.PlaneIntersectionType) –

System.Nullable<Single> Intersects(Ray ray)

Gets whether or not a specified T:Microsoft.Xna.Framework.Ray intersects with this sphere.

Parameters:

• ray (Microsoft.Xna.Framework.Ray) – The ray for testing.

Returns:

Distance of ray intersection or null if there is no intersection.

void Intersects(ref Ray ray, ref System.Nullable<Single> result)

Parameters:

• (ref) ray (Microsoft.Xna.Framework.Ray) –
• (ref) result (System.Nullable<Single>) –

string ToString()

Returns a T:System.String representation of this T:Microsoft.Xna.Framework.BoundingSphere in the format: {Center:[F:Microsoft.Xna.Framework.BoundingSphere.Center] Radius:[F:Microsoft.Xna.Framework.BoundingSphere.Radius]}

Returns:A T:System.String representation of this T:Microsoft.Xna.Framework.BoundingSphere.

BoundingSphere Transform(Matrix matrix)

Creates a new T:Microsoft.Xna.Framework.BoundingSphere that contains a transformation of translation and scale from this sphere by the specified T:Microsoft.Xna.Framework.Matrix.

Parameters:

• matrix (Microsoft.Xna.Framework.Matrix) – The transformation T:Microsoft.Xna.Framework.Matrix.

Returns:

Transformed T:Microsoft.Xna.Framework.BoundingSphere.

void Transform(ref Matrix matrix, ref BoundingSphere result)

Parameters:

• (ref) matrix (Microsoft.Xna.Framework.Matrix) –
• (ref) result (Microsoft.Xna.Framework.BoundingSphere) –

bool op_Equality(BoundingSphere a, BoundingSphere b)

Compares whether two T:Microsoft.Xna.Framework.BoundingSphere instances are equal.

Parameters:

• a (Microsoft.Xna.Framework.BoundingSphere) – T:Microsoft.Xna.Framework.BoundingSphere instance on the left of the equal sign.
• b (Microsoft.Xna.Framework.BoundingSphere) – T:Microsoft.Xna.Framework.BoundingSphere instance on the right of the equal sign.

Returns:

true if the instances are equal; false otherwise.

bool op_Inequality(BoundingSphere a, BoundingSphere b)

Compares whether two T:Microsoft.Xna.Framework.BoundingSphere instances are not equal.

Parameters:

• a (Microsoft.Xna.Framework.BoundingSphere) – T:Microsoft.Xna.Framework.BoundingSphere instance on the left of the not equal sign.
• b (Microsoft.Xna.Framework.BoundingSphere) – T:Microsoft.Xna.Framework.BoundingSphere instance on the right of the not equal sign.

Returns:

true if the instances are not equal; false otherwise.

BufferUsage

enum BufferUsage : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

A usage hint for optimizing memory placement of graphics buffers.

BufferUsage None

No special usage.

BufferUsage WriteOnly

The buffer will not be readable and will be optimized for rendering and writing.

Buttons

enum Buttons : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines the buttons on gamepad.

Buttons DPadUp

Directional pad up.

Buttons DPadDown

Directional pad down.

Buttons DPadLeft

Directional pad left.

Buttons DPadRight

Directional pad right.

Buttons Start

START button.

Buttons Back

BACK button.

Buttons LeftStick

Left stick button (pressing the left stick).

Buttons RightStick

Right stick button (pressing the right stick).

Buttons LeftShoulder

Left bumper (shoulder) button.

Buttons RightShoulder

Right bumper (shoulder) button.

Buttons BigButton

Big button.

Buttons A

A button.

Buttons B

B button.

Buttons X

X button.

Buttons Y

Y button.

Buttons LeftThumbstickLeft

Left stick is towards the left.

Buttons RightTrigger

Right trigger.

Buttons LeftTrigger

Left trigger.

Buttons RightThumbstickUp

Right stick is towards up.

Buttons RightThumbstickDown

Right stick is towards down.

Buttons RightThumbstickRight

Right stick is towards the right.

Buttons RightThumbstickLeft

Right stick is towards the left.

Buttons LeftThumbstickUp

Left stick is towards up.

Buttons LeftThumbstickDown

Left stick is towards down.

Buttons LeftThumbstickRight

Left stick is towards the right.

ButtonState

enum ButtonState : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines a button state for buttons of mouse, gamepad or joystick.

ButtonState Released

The button is released.

ButtonState Pressed

The button is pressed.

Byte4

struct Byte4 : System.ValueType, Microsoft.Xna.Framework.Graphics.PackedVector.IPackedVector<UInt32>, IPackedVector, System.IEquatable<Byte4>

Packed vector type containing four 8-bit unsigned integer values, ranging from 0 to 255.

uint PackedValue

Directly gets or sets the packed representation of the value.

Value:The packed representation of the value.

bool op_Inequality(Byte4 a, Byte4 b)

Compares the current instance of a class to another instance to determine whether they are different.

Parameters:

• a (Microsoft.Xna.Framework.Graphics.PackedVector.Byte4) – The object to the left of the equality operator.
• b (Microsoft.Xna.Framework.Graphics.PackedVector.Byte4) – The object to the right of the equality operator.

Returns:

true if the objects are different; false otherwise.

bool op_Equality(Byte4 a, Byte4 b)

Compares the current instance of a class to another instance to determine whether they are the same.

Parameters:

• a (Microsoft.Xna.Framework.Graphics.PackedVector.Byte4) – The object to the left of the equality operator.
• b (Microsoft.Xna.Framework.Graphics.PackedVector.Byte4) – The object to the right of the equality operator.

Returns:

true if the objects are the same; false otherwise.

bool Equals(System.Object obj)

Returns a value that indicates whether the current instance is equal to a specified object.

Parameters:

• obj (System.Object) – The object with which to make the comparison.

Returns:

true if the current instance is equal to the specified object; false otherwise.

bool Equals(Byte4 other)

Returns a value that indicates whether the current instance is equal to a specified object.

Parameters:

• other (Microsoft.Xna.Framework.Graphics.PackedVector.Byte4) – The object with which to make the comparison.

Returns:

true if the current instance is equal to the specified object; false otherwise.

int GetHashCode()

Gets the hash code for the current instance.

Returns:Hash code for the instance.

string ToString()

Returns a string representation of the current instance.

Returns:String that represents the object.

Vector4 ToVector4()

Expands the packed representation into a Vector4.

Returns:The expanded vector.

ClearOptions

enum ClearOptions : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines the buffers for clearing when calling M:Microsoft.Xna.Framework.Graphics.GraphicsDevice.Clear(Microsoft.Xna.Framework.Graphics.ClearOptions,Microsoft.Xna.Framework.Color,System.Single,System.Int32) operation.

ClearOptions Target

Color buffer.

ClearOptions DepthBuffer

Depth buffer.

ClearOptions Stencil

Stencil buffer.

Color

struct Color : System.ValueType, System.IEquatable<Color>

Describes a 32-bit packed color.

byte B

Gets or sets the blue component.

byte G

Gets or sets the green component.

byte R

Gets or sets the red component.

byte A

Gets or sets the alpha component.

readonly Color TransparentBlack

TransparentBlack color (R:0,G:0,B:0,A:0).

readonly Color Transparent

Transparent color (R:0,G:0,B:0,A:0).

readonly Color AliceBlue

AliceBlue color (R:240,G:248,B:255,A:255).

readonly Color AntiqueWhite

AntiqueWhite color (R:250,G:235,B:215,A:255).

readonly Color Aqua

Aqua color (R:0,G:255,B:255,A:255).

readonly Color Aquamarine

Aquamarine color (R:127,G:255,B:212,A:255).

readonly Color Azure

Azure color (R:240,G:255,B:255,A:255).

readonly Color Beige

Beige color (R:245,G:245,B:220,A:255).

readonly Color Bisque

Bisque color (R:255,G:228,B:196,A:255).

readonly Color Black

Black color (R:0,G:0,B:0,A:255).

readonly Color BlanchedAlmond

BlanchedAlmond color (R:255,G:235,B:205,A:255).

readonly Color Blue

Blue color (R:0,G:0,B:255,A:255).

readonly Color BlueViolet

BlueViolet color (R:138,G:43,B:226,A:255).

readonly Color Brown

Brown color (R:165,G:42,B:42,A:255).

readonly Color BurlyWood

BurlyWood color (R:222,G:184,B:135,A:255).

readonly Color CadetBlue

CadetBlue color (R:95,G:158,B:160,A:255).

readonly Color Chartreuse

Chartreuse color (R:127,G:255,B:0,A:255).

readonly Color Chocolate

Chocolate color (R:210,G:105,B:30,A:255).

readonly Color Coral

Coral color (R:255,G:127,B:80,A:255).

readonly Color CornflowerBlue

CornflowerBlue color (R:100,G:149,B:237,A:255).

readonly Color Cornsilk

Cornsilk color (R:255,G:248,B:220,A:255).

readonly Color Crimson

Crimson color (R:220,G:20,B:60,A:255).

readonly Color Cyan

Cyan color (R:0,G:255,B:255,A:255).

readonly Color DarkBlue

DarkBlue color (R:0,G:0,B:139,A:255).

readonly Color DarkCyan

DarkCyan color (R:0,G:139,B:139,A:255).

readonly Color DarkGoldenrod

DarkGoldenrod color (R:184,G:134,B:11,A:255).

readonly Color DarkGray

DarkGray color (R:169,G:169,B:169,A:255).

readonly Color DarkGreen

DarkGreen color (R:0,G:100,B:0,A:255).

readonly Color DarkKhaki

DarkKhaki color (R:189,G:183,B:107,A:255).

readonly Color DarkMagenta

DarkMagenta color (R:139,G:0,B:139,A:255).

readonly Color DarkOliveGreen

DarkOliveGreen color (R:85,G:107,B:47,A:255).

readonly Color DarkOrange

DarkOrange color (R:255,G:140,B:0,A:255).

readonly Color DarkOrchid

DarkOrchid color (R:153,G:50,B:204,A:255).

readonly Color DarkRed

DarkRed color (R:139,G:0,B:0,A:255).

readonly Color DarkSalmon

DarkSalmon color (R:233,G:150,B:122,A:255).

readonly Color DarkSeaGreen

DarkSeaGreen color (R:143,G:188,B:139,A:255).

readonly Color DarkSlateBlue

DarkSlateBlue color (R:72,G:61,B:139,A:255).

readonly Color DarkSlateGray

DarkSlateGray color (R:47,G:79,B:79,A:255).

readonly Color DarkTurquoise

DarkTurquoise color (R:0,G:206,B:209,A:255).

readonly Color DarkViolet

DarkViolet color (R:148,G:0,B:211,A:255).

readonly Color DeepPink

DeepPink color (R:255,G:20,B:147,A:255).

readonly Color DeepSkyBlue

DeepSkyBlue color (R:0,G:191,B:255,A:255).

readonly Color DimGray

DimGray color (R:105,G:105,B:105,A:255).

readonly Color DodgerBlue

DodgerBlue color (R:30,G:144,B:255,A:255).

readonly Color Firebrick

Firebrick color (R:178,G:34,B:34,A:255).

readonly Color FloralWhite

FloralWhite color (R:255,G:250,B:240,A:255).

readonly Color ForestGreen

ForestGreen color (R:34,G:139,B:34,A:255).

readonly Color Fuchsia

Fuchsia color (R:255,G:0,B:255,A:255).

readonly Color Gainsboro

Gainsboro color (R:220,G:220,B:220,A:255).

readonly Color GhostWhite

GhostWhite color (R:248,G:248,B:255,A:255).

readonly Color Gold

Gold color (R:255,G:215,B:0,A:255).

readonly Color Goldenrod

Goldenrod color (R:218,G:165,B:32,A:255).

readonly Color Gray

Gray color (R:128,G:128,B:128,A:255).

readonly Color Green

Green color (R:0,G:128,B:0,A:255).

readonly Color GreenYellow

GreenYellow color (R:173,G:255,B:47,A:255).

readonly Color Honeydew

Honeydew color (R:240,G:255,B:240,A:255).

readonly Color HotPink

HotPink color (R:255,G:105,B:180,A:255).

readonly Color IndianRed

IndianRed color (R:205,G:92,B:92,A:255).

readonly Color Indigo

Indigo color (R:75,G:0,B:130,A:255).

readonly Color Ivory

Ivory color (R:255,G:255,B:240,A:255).

readonly Color Khaki

Khaki color (R:240,G:230,B:140,A:255).

readonly Color Lavender

Lavender color (R:230,G:230,B:250,A:255).

readonly Color LavenderBlush

LavenderBlush color (R:255,G:240,B:245,A:255).

readonly Color LawnGreen

LawnGreen color (R:124,G:252,B:0,A:255).

readonly Color LemonChiffon

LemonChiffon color (R:255,G:250,B:205,A:255).

readonly Color LightBlue

LightBlue color (R:173,G:216,B:230,A:255).

readonly Color LightCoral

LightCoral color (R:240,G:128,B:128,A:255).

readonly Color LightCyan

LightCyan color (R:224,G:255,B:255,A:255).

readonly Color LightGoldenrodYellow

LightGoldenrodYellow color (R:250,G:250,B:210,A:255).

readonly Color LightGray

LightGray color (R:211,G:211,B:211,A:255).

readonly Color LightGreen

LightGreen color (R:144,G:238,B:144,A:255).

readonly Color LightPink

LightPink color (R:255,G:182,B:193,A:255).

readonly Color LightSalmon

LightSalmon color (R:255,G:160,B:122,A:255).

readonly Color LightSeaGreen

LightSeaGreen color (R:32,G:178,B:170,A:255).

readonly Color LightSkyBlue

LightSkyBlue color (R:135,G:206,B:250,A:255).

readonly Color LightSlateGray

LightSlateGray color (R:119,G:136,B:153,A:255).

readonly Color LightSteelBlue

LightSteelBlue color (R:176,G:196,B:222,A:255).

readonly Color LightYellow

LightYellow color (R:255,G:255,B:224,A:255).

readonly Color Lime

Lime color (R:0,G:255,B:0,A:255).

readonly Color LimeGreen

LimeGreen color (R:50,G:205,B:50,A:255).

readonly Color Linen

Linen color (R:250,G:240,B:230,A:255).

readonly Color Magenta

Magenta color (R:255,G:0,B:255,A:255).

readonly Color Maroon

Maroon color (R:128,G:0,B:0,A:255).

readonly Color MediumAquamarine

MediumAquamarine color (R:102,G:205,B:170,A:255).

readonly Color MediumBlue

MediumBlue color (R:0,G:0,B:205,A:255).

readonly Color MediumOrchid

MediumOrchid color (R:186,G:85,B:211,A:255).

readonly Color MediumPurple

MediumPurple color (R:147,G:112,B:219,A:255).

readonly Color MediumSeaGreen

MediumSeaGreen color (R:60,G:179,B:113,A:255).

readonly Color MediumSlateBlue

MediumSlateBlue color (R:123,G:104,B:238,A:255).

readonly Color MediumSpringGreen

MediumSpringGreen color (R:0,G:250,B:154,A:255).

readonly Color MediumTurquoise

MediumTurquoise color (R:72,G:209,B:204,A:255).

readonly Color MediumVioletRed

MediumVioletRed color (R:199,G:21,B:133,A:255).

readonly Color MidnightBlue

MidnightBlue color (R:25,G:25,B:112,A:255).

readonly Color MintCream

MintCream color (R:245,G:255,B:250,A:255).

readonly Color MistyRose

MistyRose color (R:255,G:228,B:225,A:255).

readonly Color Moccasin

Moccasin color (R:255,G:228,B:181,A:255).

readonly Color MonoGameOrange

MonoGame orange theme color (R:231,G:60,B:0,A:255).

readonly Color NavajoWhite

NavajoWhite color (R:255,G:222,B:173,A:255).

readonly Color Navy

Navy color (R:0,G:0,B:128,A:255).

readonly Color OldLace

OldLace color (R:253,G:245,B:230,A:255).

readonly Color Olive

Olive color (R:128,G:128,B:0,A:255).

readonly Color OliveDrab

OliveDrab color (R:107,G:142,B:35,A:255).

readonly Color Orange

Orange color (R:255,G:165,B:0,A:255).

readonly Color OrangeRed

OrangeRed color (R:255,G:69,B:0,A:255).

readonly Color Orchid

Orchid color (R:218,G:112,B:214,A:255).

readonly Color PaleGoldenrod

PaleGoldenrod color (R:238,G:232,B:170,A:255).

readonly Color PaleGreen

PaleGreen color (R:152,G:251,B:152,A:255).

readonly Color PaleTurquoise

PaleTurquoise color (R:175,G:238,B:238,A:255).

readonly Color PaleVioletRed

PaleVioletRed color (R:219,G:112,B:147,A:255).

readonly Color PapayaWhip

PapayaWhip color (R:255,G:239,B:213,A:255).

readonly Color PeachPuff

PeachPuff color (R:255,G:218,B:185,A:255).

readonly Color Peru

Peru color (R:205,G:133,B:63,A:255).

readonly Color Pink

Pink color (R:255,G:192,B:203,A:255).

readonly Color Plum

Plum color (R:221,G:160,B:221,A:255).

readonly Color PowderBlue

PowderBlue color (R:176,G:224,B:230,A:255).

readonly Color Purple

Purple color (R:128,G:0,B:128,A:255).

readonly Color Red

Red color (R:255,G:0,B:0,A:255).

readonly Color RosyBrown

RosyBrown color (R:188,G:143,B:143,A:255).

readonly Color RoyalBlue

RoyalBlue color (R:65,G:105,B:225,A:255).

readonly Color SaddleBrown

SaddleBrown color (R:139,G:69,B:19,A:255).

readonly Color Salmon

Salmon color (R:250,G:128,B:114,A:255).

readonly Color SandyBrown

SandyBrown color (R:244,G:164,B:96,A:255).

readonly Color SeaGreen

SeaGreen color (R:46,G:139,B:87,A:255).

readonly Color SeaShell

SeaShell color (R:255,G:245,B:238,A:255).

readonly Color Sienna

Sienna color (R:160,G:82,B:45,A:255).

readonly Color Silver

Silver color (R:192,G:192,B:192,A:255).

readonly Color SkyBlue

SkyBlue color (R:135,G:206,B:235,A:255).

readonly Color SlateBlue

SlateBlue color (R:106,G:90,B:205,A:255).

readonly Color SlateGray

SlateGray color (R:112,G:128,B:144,A:255).

readonly Color Snow

Snow color (R:255,G:250,B:250,A:255).

readonly Color SpringGreen

SpringGreen color (R:0,G:255,B:127,A:255).

readonly Color SteelBlue

SteelBlue color (R:70,G:130,B:180,A:255).

readonly Color Tan

Tan color (R:210,G:180,B:140,A:255).

readonly Color Teal

Teal color (R:0,G:128,B:128,A:255).

readonly Color Thistle

Thistle color (R:216,G:191,B:216,A:255).

readonly Color Tomato

Tomato color (R:255,G:99,B:71,A:255).

readonly Color Turquoise

Turquoise color (R:64,G:224,B:208,A:255).

readonly Color Violet

Violet color (R:238,G:130,B:238,A:255).

readonly Color Wheat

Wheat color (R:245,G:222,B:179,A:255).

readonly Color White

White color (R:255,G:255,B:255,A:255).

readonly Color WhiteSmoke

WhiteSmoke color (R:245,G:245,B:245,A:255).

readonly Color Yellow

Yellow color (R:255,G:255,B:0,A:255).

readonly Color YellowGreen

YellowGreen color (R:154,G:205,B:50,A:255).

uint PackedValue

Gets or sets packed value of this T:Microsoft.Xna.Framework.Color.

Color Lerp(Color value1, Color value2, float amount)

Performs linear interpolation of T:Microsoft.Xna.Framework.Color.

Parameters:

• value1 (Microsoft.Xna.Framework.Color) – Source T:Microsoft.Xna.Framework.Color.
• value2 (Microsoft.Xna.Framework.Color) – Destination T:Microsoft.Xna.Framework.Color.
• amount (float) – Interpolation factor.

Returns:

Interpolated T:Microsoft.Xna.Framework.Color.

Color LerpPrecise(Color value1, Color value2, float amount)

M:Microsoft.Xna.Framework.Color.Lerp(Microsoft.Xna.Framework.Color,Microsoft.Xna.Framework.Color,System.Single) should be used instead of this function.

Parameters:

• value1 (Microsoft.Xna.Framework.Color) –
• value2 (Microsoft.Xna.Framework.Color) –
• amount (float) –

Returns:

Interpolated T:Microsoft.Xna.Framework.Color.

Color Multiply(Color value, float scale)

Multiply T:Microsoft.Xna.Framework.Color by value.

Parameters:

• value (Microsoft.Xna.Framework.Color) – Source T:Microsoft.Xna.Framework.Color.
• scale (float) – Multiplicator.

Returns:

Multiplication result.

Color op_Multiply(Color value, float scale)

Multiply T:Microsoft.Xna.Framework.Color by value.

Parameters:

• value (Microsoft.Xna.Framework.Color) – Source T:Microsoft.Xna.Framework.Color.
• scale (float) – Multiplicator.

Returns:

Multiplication result.

Vector3 ToVector3()

Gets a T:Microsoft.Xna.Framework.Vector3 representation for this object.

Returns:A T:Microsoft.Xna.Framework.Vector3 representation for this object.

Vector4 ToVector4()

Gets a T:Microsoft.Xna.Framework.Vector4 representation for this object.

Returns:A T:Microsoft.Xna.Framework.Vector4 representation for this object.

string get_DebugDisplayString()

string ToString()

Returns a T:System.String representation of this T:Microsoft.Xna.Framework.Color in the format: {R:[red] G:[green] B:[blue] A:[alpha]}

Returns:T:System.String representation of this T:Microsoft.Xna.Framework.Color.

Color FromNonPremultiplied(Vector4 vector)

Translate a non-premultipled alpha T:Microsoft.Xna.Framework.Color to a T:Microsoft.Xna.Framework.Color that contains premultiplied alpha.

Parameters:

• vector (Microsoft.Xna.Framework.Vector4) – A T:Microsoft.Xna.Framework.Vector4 representing color.

Returns:

A T:Microsoft.Xna.Framework.Color which contains premultiplied alpha data.

Color FromNonPremultiplied(int r, int g, int b, int a)

Translate a non-premultipled alpha T:Microsoft.Xna.Framework.Color to a T:Microsoft.Xna.Framework.Color that contains premultiplied alpha.

Parameters:

• r (int) – Red component value.
• g (int) – Green component value.
• b (int) – Blue component value.
• a (int) – Alpha component value.

Returns:

A T:Microsoft.Xna.Framework.Color which contains premultiplied alpha data.

bool Equals(Color other)

Compares whether current instance is equal to specified T:Microsoft.Xna.Framework.Color.

Parameters:

• other (Microsoft.Xna.Framework.Color) – The T:Microsoft.Xna.Framework.Color to compare.

Returns:

true if the instances are equal; false otherwise.

bool op_Equality(Color a, Color b)

Compares whether two T:Microsoft.Xna.Framework.Color instances are equal.

Parameters:

• a (Microsoft.Xna.Framework.Color) – T:Microsoft.Xna.Framework.Color instance on the left of the equal sign.
• b (Microsoft.Xna.Framework.Color) – T:Microsoft.Xna.Framework.Color instance on the right of the equal sign.

Returns:

true if the instances are equal; false otherwise.

bool op_Inequality(Color a, Color b)

Compares whether two T:Microsoft.Xna.Framework.Color instances are not equal.

Parameters:

• a (Microsoft.Xna.Framework.Color) – T:Microsoft.Xna.Framework.Color instance on the left of the not equal sign.
• b (Microsoft.Xna.Framework.Color) – T:Microsoft.Xna.Framework.Color instance on the right of the not equal sign.

Returns:

true if the instances are not equal; false otherwise.

int GetHashCode()

Gets the hash code of this T:Microsoft.Xna.Framework.Color.

Returns:Hash code of this T:Microsoft.Xna.Framework.Color.

bool Equals(System.Object obj)

Compares whether current instance is equal to specified object.

Parameters:

• obj (System.Object) – The T:Microsoft.Xna.Framework.Color to compare.

Returns:

true if the instances are equal; false otherwise.

ColorWriteChannels

enum ColorWriteChannels : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines the color channels for render target blending operations.

ColorWriteChannels None

No channels selected.

ColorWriteChannels Red

Red channel selected.

ColorWriteChannels Green

Green channel selected.

ColorWriteChannels Blue

Blue channel selected.

ColorWriteChannels Alpha

Alpha channel selected.

ColorWriteChannels All

All channels selected.

CompareFunction

enum CompareFunction : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

The comparison function used for depth, stencil, and alpha tests.

CompareFunction Always

Always passes the test.

CompareFunction Never

Never passes the test.

CompareFunction Less

Passes the test when the new pixel value is less than current pixel value.

CompareFunction LessEqual

Passes the test when the new pixel value is less than or equal to current pixel value.

CompareFunction Equal

Passes the test when the new pixel value is equal to current pixel value.

CompareFunction GreaterEqual

Passes the test when the new pixel value is greater than or equal to current pixel value.

CompareFunction Greater

Passes the test when the new pixel value is greater than current pixel value.

CompareFunction NotEqual

Passes the test when the new pixel value does not equal to current pixel value.

CompressionLevel

enum CompressionLevel : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

The compression level to be used when using a DeflateStream or ZlibStream with CompressionMode.Compress.

CompressionLevel None

None means that the data will be simply stored, with no change at all. If you are producing ZIPs for use on Mac OSX, be aware that archives produced with CompressionLevel.None cannot be opened with the default zip reader. Use a different CompressionLevel.

CompressionLevel Level0

Same as None.

CompressionLevel BestSpeed

The fastest but least effective compression.

CompressionLevel Level1

A synonym for BestSpeed.

CompressionLevel Level2

A little slower, but better, than level 1.

CompressionLevel Level3

A little slower, but better, than level 2.

CompressionLevel Level4

A little slower, but better, than level 3.

CompressionLevel Level5

A little slower than level 4, but with better compression.

CompressionLevel Default

The default compression level, with a good balance of speed and compression efficiency.

CompressionLevel Level6

A synonym for Default.

CompressionLevel Level7

Pretty good compression!

CompressionLevel Level8

Better compression than Level7!

CompressionLevel BestCompression

The “best” compression, where best means greatest reduction in size of the input data stream. This is also the slowest compression.

CompressionLevel Level9

A synonym for BestCompression.

CompressionMode

enum CompressionMode : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

An enum to specify the direction of transcoding - whether to compress or decompress.

CompressionMode Compress

Used to specify that the stream should compress the data.

CompressionMode Decompress

Used to specify that the stream should decompress the data.

ContainmentType

enum ContainmentType : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines how the bounding volumes intersects or contain one another.

ContainmentType Disjoint

Indicates that there is no overlap between two bounding volumes.

ContainmentType Contains

Indicates that one bounding volume completely contains another volume.

ContainmentType Intersects

Indicates that bounding volumes partially overlap one another.

ContentLoadException

class ContentLoadException : System.Exception, System.Runtime.Serialization.ISerializable, System.Runtime.InteropServices._Exception

ContentManager

class ContentManager : System.Object, System.IDisposable

string RootDirectory

readonly System.IServiceProvider ServiceProvider

void ReloadGraphicsContent()

public void Dispose()

public Microsoft.Xna.Framework.Content.T Load<T>(string assetName)

Type Parameters:  

• T –

Parameters:

• assetName (string) –

void RecordDisposable(System.IDisposable disposable)

Parameters:

• disposable (System.IDisposable) –

public void Unload()

string get_RootDirectoryFullPath()

System.Byte[] GetScratchBuffer(int size)

Parameters:

• size (int) –

ContentReader

class ContentReader : System.IO.BinaryReader, System.IDisposable

readonly ContentManager ContentManager

readonly string AssetName

Microsoft.Xna.Framework.Content.ContentTypeReader[] get_TypeReaders()

GraphicsDevice get_GraphicsDevice()

System.Object ReadAsset<T>()

Type Parameters:  

• T –

System.Object ReadAsset<T>(Microsoft.Xna.Framework.Content.T existingInstance)

Type Parameters:  

• T –

Parameters:

• existingInstance (Microsoft.Xna.Framework.Content.T) –

void InitializeTypeReaders()

void ReadSharedResources()

public Microsoft.Xna.Framework.Content.T ReadExternalReference<T>()

Type Parameters:  

• T –

public Matrix ReadMatrix()

public Microsoft.Xna.Framework.Content.T ReadObject<T>()

Type Parameters:  

• T –

public Microsoft.Xna.Framework.Content.T ReadObject<T>(ContentTypeReader typeReader)

Type Parameters:  

• T –

Parameters:

• typeReader (Microsoft.Xna.Framework.Content.ContentTypeReader) –

public Microsoft.Xna.Framework.Content.T ReadObject<T>(Microsoft.Xna.Framework.Content.T existingInstance)

Type Parameters:  

• T –

Parameters:

• existingInstance (Microsoft.Xna.Framework.Content.T) –

public Microsoft.Xna.Framework.Content.T ReadObject<T>(ContentTypeReader typeReader, Microsoft.Xna.Framework.Content.T existingInstance)

Type Parameters:  

• T –

Parameters:

• typeReader (Microsoft.Xna.Framework.Content.ContentTypeReader) –
• existingInstance (Microsoft.Xna.Framework.Content.T) –

public Quaternion ReadQuaternion()

public Microsoft.Xna.Framework.Content.T ReadRawObject<T>()

Type Parameters:  

• T –

public Microsoft.Xna.Framework.Content.T ReadRawObject<T>(ContentTypeReader typeReader)

Type Parameters:  

• T –

Parameters:

• typeReader (Microsoft.Xna.Framework.Content.ContentTypeReader) –

public Microsoft.Xna.Framework.Content.T ReadRawObject<T>(Microsoft.Xna.Framework.Content.T existingInstance)

Type Parameters:  

• T –

Parameters:

• existingInstance (Microsoft.Xna.Framework.Content.T) –

public Microsoft.Xna.Framework.Content.T ReadRawObject<T>(ContentTypeReader typeReader, Microsoft.Xna.Framework.Content.T existingInstance)

Type Parameters:  

• T –

Parameters:

• typeReader (Microsoft.Xna.Framework.Content.ContentTypeReader) –
• existingInstance (Microsoft.Xna.Framework.Content.T) –

public void ReadSharedResource<T>(System.Action<T> fixup)

Type Parameters:  

• T –

Parameters:

• fixup (System.Action<T>) –

public Vector2 ReadVector2()

public Vector3 ReadVector3()

public Vector4 ReadVector4()

public Color ReadColor()

int Read7BitEncodedInt()

BoundingSphere ReadBoundingSphere()

ContentSerializerAttribute

class ContentSerializerAttribute : System.Attribute, System.Runtime.InteropServices._Attribute

bool AllowNull

string CollectionItemName

Returns the overriden XML element name or the default “Item”.

string ElementName

bool FlattenContent

readonly bool HasCollectionItemName

Returns true if the default CollectionItemName value was overridden.

bool Optional

bool SharedResource

public ContentSerializerAttribute Clone()

ContentSerializerCollectionItemNameAttribute

class ContentSerializerCollectionItemNameAttribute : System.Attribute, System.Runtime.InteropServices._Attribute

This is used to specify the XML element name to use for each item in a collection.

readonly string CollectionItemName

The XML element name to use for each item in the collection.

ContentSerializerIgnoreAttribute

class ContentSerializerIgnoreAttribute : System.Attribute, System.Runtime.InteropServices._Attribute

ContentSerializerRuntimeTypeAttribute

class ContentSerializerRuntimeTypeAttribute : System.Attribute, System.Runtime.InteropServices._Attribute

This is used to specify the type to use when deserializing this object at runtime.

readonly string RuntimeType

The name of the type to use at runtime.

ContentSerializerTypeVersionAttribute

class ContentSerializerTypeVersionAttribute : System.Attribute, System.Runtime.InteropServices._Attribute

This is used to specify the version when deserializing this object at runtime.

readonly int TypeVersion

The version passed to the type at runtime.

ContentTypeReader

class ContentTypeReader : System.Object

readonly bool CanDeserializeIntoExistingObject

readonly System.Type TargetType

readonly int TypeVersion

void Initialize(ContentTypeReaderManager manager)

Parameters:

• manager (Microsoft.Xna.Framework.Content.ContentTypeReaderManager) –

abstract System.Object Read(ContentReader input, System.Object existingInstance)

Parameters:

• input (Microsoft.Xna.Framework.Content.ContentReader) –
• existingInstance (System.Object) –

ContentTypeReader<T>

class ContentTypeReader<T> : ContentTypeReader

Type Parameters:  

• T –

System.Object Read(ContentReader input, System.Object existingInstance)

Parameters:

• input (Microsoft.Xna.Framework.Content.ContentReader) –
• existingInstance (System.Object) –

abstract Microsoft.Xna.Framework.Content.T Read(ContentReader input, Microsoft.Xna.Framework.Content.T existingInstance)

Parameters:

• input (Microsoft.Xna.Framework.Content.ContentReader) –
• existingInstance (Microsoft.Xna.Framework.Content.T) –

ContentTypeReaderManager

class ContentTypeReaderManager : System.Object

public ContentTypeReader GetTypeReader(System.Type targetType)

Parameters:

• targetType (System.Type) –

Microsoft.Xna.Framework.Content.ContentTypeReader[] LoadAssetReaders(ContentReader reader)

Parameters:

• reader (Microsoft.Xna.Framework.Content.ContentReader) –

public string PrepareType(string type)

Removes Version, Culture and PublicKeyToken from a type string.

Parameters:

• type (string) – A T:System.String

Returns:

A T:System.String

public void AddTypeCreator(string typeString, System.Func<ContentTypeReader> createFunction)

Adds the type creator.

Parameters:

• typeString (string) – Type string.
• createFunction (System.Func<ContentTypeReader>) – Create function.

public void ClearTypeCreators()

CubeMapFace

enum CubeMapFace : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines the faces in a cube map for the T:Microsoft.Xna.Framework.Graphics.TextureCube class.

CubeMapFace PositiveX

Positive X face in the cube map.

CubeMapFace NegativeX

Negative X face in the cube map.

CubeMapFace PositiveY

Positive Y face in the cube map.

CubeMapFace NegativeY

Negative Y face in the cube map.

CubeMapFace PositiveZ

Positive Z face in the cube map.

CubeMapFace NegativeZ

Negative Z face in the cube map.

Cue

class Cue : System.Object, System.IDisposable

Manages the playback of a sound or set of sounds.

readonly bool IsPaused

Indicates whether or not the cue is currently paused.

readonly bool IsPlaying

Indicates whether or not the cue is currently playing.

readonly bool IsStopped

Indicates whether or not the cue is currently stopped.

readonly bool IsStopping

readonly bool IsPreparing

readonly bool IsPrepared

readonly bool IsCreated

readonly string Name

Gets the friendly name of the cue.

readonly bool IsDisposed

Is true if the Cue has been disposed.

void set_IsPrepared(bool value)

Parameters:

• value (bool) –

void set_IsCreated(bool value)

Parameters:

• value (bool) –

void Prepare()

public void Pause()

Pauses playback.

public void Play()

Requests playback of a prepared or preparing Cue.

public void Resume()

Resumes playback of a paused Cue.

public void Stop(AudioStopOptions options)

Stops playback of a Cue.

Parameters:

• options (Microsoft.Xna.Framework.Audio.AudioStopOptions) – Specifies if the sound should play any pending release phases or transitions before stopping.

public void SetVariable(string name, float value)

Sets the value of a cue-instance variable based on its friendly name.

Parameters:

• name (string) – Friendly name of the variable to set.
• value (float) – Value to assign to the variable.

public float GetVariable(string name)

Gets a cue-instance variable value based on its friendly name.

Parameters:

• name (string) – Friendly name of the variable.

Returns:

Value of the variable.

public void Apply3D(AudioListener listener, AudioEmitter emitter)

Updates the simulated 3D Audio settings calculated between an AudioEmitter and AudioListener.

Parameters:

• listener (Microsoft.Xna.Framework.Audio.AudioListener) – The listener to calculate.
• emitter (Microsoft.Xna.Framework.Audio.AudioEmitter) – The emitter to calculate.

void Update(float dt)

Parameters:

• dt (float) –

public void add_Disposing(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_Disposing(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

void set_IsDisposed(bool value)

Parameters:

• value (bool) –

public void Dispose()

Disposes the Cue.

CullMode

enum CullMode : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines a culling mode for faces in rasterization process.

CullMode None

Do not cull faces.

CullMode CullClockwiseFace

Cull faces with clockwise order.

CullMode CullCounterClockwiseFace

Cull faces with counter clockwise order.

Curve

class Curve : System.Object

Contains a collection of T:Microsoft.Xna.Framework.CurveKey points in 2D space and provides methods for evaluating features of the curve they define.

readonly bool IsConstant

Returns true if this curve is constant (has zero or one points); false otherwise.

readonly CurveKeyCollection Keys

The collection of curve keys.

CurveLoopType PostLoop

Defines how to handle weighting values that are greater than the last control point in the curve.

CurveLoopType PreLoop

Defines how to handle weighting values that are less than the first control point in the curve.

public Curve Clone()

Creates a copy of this curve.

Returns:A copy of this curve.

public float Evaluate(float position)

Evaluate the value at a position of this T:Microsoft.Xna.Framework.Curve.

Parameters:

• position (float) – The position on this T:Microsoft.Xna.Framework.Curve.

Returns:

Value at the position on this T:Microsoft.Xna.Framework.Curve.

public void ComputeTangents(CurveTangent tangentType)

Computes tangents for all keys in the collection.

Parameters:

• tangentType (Microsoft.Xna.Framework.CurveTangent) – The tangent type for both in and out.

public void ComputeTangents(CurveTangent tangentInType, CurveTangent tangentOutType)

Computes tangents for all keys in the collection.

Parameters:

• tangentInType (Microsoft.Xna.Framework.CurveTangent) – The tangent in-type. P:Microsoft.Xna.Framework.CurveKey.TangentIn for more details.
• tangentOutType (Microsoft.Xna.Framework.CurveTangent) – The tangent out-type. P:Microsoft.Xna.Framework.CurveKey.TangentOut for more details.

public void ComputeTangent(int keyIndex, CurveTangent tangentType)

Computes tangent for the specific key in the collection.

Parameters:

• keyIndex (int) – The index of a key in the collection.
• tangentType (Microsoft.Xna.Framework.CurveTangent) – The tangent type for both in and out.

public void ComputeTangent(int keyIndex, CurveTangent tangentInType, CurveTangent tangentOutType)

Computes tangent for the specific key in the collection.

Parameters:

• keyIndex (int) – The index of key in the collection.
• tangentInType (Microsoft.Xna.Framework.CurveTangent) – The tangent in-type. P:Microsoft.Xna.Framework.CurveKey.TangentIn for more details.
• tangentOutType (Microsoft.Xna.Framework.CurveTangent) – The tangent out-type. P:Microsoft.Xna.Framework.CurveKey.TangentOut for more details.

CurveContinuity

enum CurveContinuity : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines the continuity of keys on a T:Microsoft.Xna.Framework.Curve.

CurveContinuity Smooth

Interpolation can be used between this key and the next.

CurveContinuity Step

Interpolation cannot be used. A position between the two points returns this point.

CurveKey

class CurveKey : System.Object, System.IEquatable<CurveKey>, System.IComparable<CurveKey>

Key point on the T:Microsoft.Xna.Framework.Curve.

CurveContinuity Continuity

Gets or sets the indicator whether the segment between this point and the next point on the curve is discrete or continuous.

readonly float Position

Gets a position of the key on the curve.

float TangentIn

Gets or sets a tangent when approaching this point from the previous point on the curve.

float TangentOut

Gets or sets a tangent when leaving this point to the next point on the curve.

float Value

Gets a value of this point.

public bool op_Inequality(CurveKey value1, CurveKey value2)

Compares whether two T:Microsoft.Xna.Framework.CurveKey instances are not equal.

Parameters:

• value1 (Microsoft.Xna.Framework.CurveKey) – T:Microsoft.Xna.Framework.CurveKey instance on the left of the not equal sign.
• value2 (Microsoft.Xna.Framework.CurveKey) – T:Microsoft.Xna.Framework.CurveKey instance on the right of the not equal sign.

Returns:

true if the instances are not equal; false otherwise.

public bool op_Equality(CurveKey value1, CurveKey value2)

Compares whether two T:Microsoft.Xna.Framework.CurveKey instances are equal.

Parameters:

• value1 (Microsoft.Xna.Framework.CurveKey) – T:Microsoft.Xna.Framework.CurveKey instance on the left of the equal sign.
• value2 (Microsoft.Xna.Framework.CurveKey) – T:Microsoft.Xna.Framework.CurveKey instance on the right of the equal sign.

Returns:

true if the instances are equal; false otherwise.

public CurveKey Clone()

Creates a copy of this key.

Returns:A copy of this key.

public int CompareTo(CurveKey other)

Parameters:

• other (Microsoft.Xna.Framework.CurveKey) –

public bool Equals(CurveKey other)

Parameters:

• other (Microsoft.Xna.Framework.CurveKey) –

public bool Equals(System.Object obj)

Parameters:

• obj (System.Object) –

public int GetHashCode()

CurveKeyCollection

class CurveKeyCollection : System.Object, System.Collections.Generic.ICollection<CurveKey>, System.Collections.Generic.IEnumerable<CurveKey>, System.Collections.IEnumerable

The collection of the T:Microsoft.Xna.Framework.CurveKey elements and a part of the T:Microsoft.Xna.Framework.Curve class.

CurveKey Item

readonly int Count

Returns the count of keys in this collection.

readonly bool IsReadOnly

Returns false because it is not a read-only collection.

public void Add(CurveKey item)

Adds a key to this collection.

Parameters:

• item (Microsoft.Xna.Framework.CurveKey) – New key for the collection.

public void Clear()

Removes all keys from this collection.

public CurveKeyCollection Clone()

Creates a copy of this collection.

Returns:A copy of this collection.

public bool Contains(CurveKey item)

Determines whether this collection contains a specific key.

Parameters:

• item (Microsoft.Xna.Framework.CurveKey) – The key to locate in this collection.

Returns:

true if the key is found; false otherwise.

public void CopyTo(Microsoft.Xna.Framework.CurveKey[] array, int arrayIndex)

Copies the keys of this collection to an array, starting at the array index provided.

Parameters:

• array (Microsoft.Xna.Framework.CurveKey[]) – Destination array where elements will be copied.
• arrayIndex (int) – The zero-based index in the array to start copying from.

public System.Collections.Generic.IEnumerator<CurveKey> GetEnumerator()

Returns an enumerator that iterates through the collection.

Returns:An enumerator for the T:Microsoft.Xna.Framework.CurveKeyCollection.

public int IndexOf(CurveKey item)

Finds element in the collection and returns its index.

Parameters:

• item (Microsoft.Xna.Framework.CurveKey) – Element for the search.

Returns:

Index of the element; or -1 if item is not found.

public void RemoveAt(int index)

Removes element at the specified index.

Parameters:

• index (int) – The index which element will be removed.

public bool Remove(CurveKey item)

Removes specific element.

Parameters:

• item (Microsoft.Xna.Framework.CurveKey) – The element

Returns:

true if item is successfully removed; false otherwise. This method also returns false if item was not found.

CurveLoopType

enum CurveLoopType : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines how the T:Microsoft.Xna.Framework.Curve value is determined for position before first point or after the end point on the T:Microsoft.Xna.Framework.Curve.

CurveLoopType Constant

The value of T:Microsoft.Xna.Framework.Curve will be evaluated as first point for positions before the beginning and end point for positions after the end.

CurveLoopType Cycle

The positions will wrap around from the end to beginning of the T:Microsoft.Xna.Framework.Curve for determined the value.

CurveLoopType CycleOffset

The positions will wrap around from the end to beginning of the T:Microsoft.Xna.Framework.Curve. The value will be offset by the difference between the values of first and end T:Microsoft.Xna.Framework.CurveKey multiplied by the wrap amount. If the position is before the beginning of the T:Microsoft.Xna.Framework.Curve the difference will be subtracted from its value; otherwise the difference will be added.

CurveLoopType Oscillate

The value at the end of the T:Microsoft.Xna.Framework.Curve act as an offset from the same side of the T:Microsoft.Xna.Framework.Curve toward the opposite side.

CurveLoopType Linear

The linear interpolation will be performed for determined the value.

CurveTangent

enum CurveTangent : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines the different tangent types to be calculated for T:Microsoft.Xna.Framework.CurveKey points in a T:Microsoft.Xna.Framework.Curve.

CurveTangent Flat

The tangent which always has a value equal to zero.

CurveTangent Linear

The tangent which contains a difference between current tangent value and the tangent value from the previous T:Microsoft.Xna.Framework.CurveKey.

CurveTangent Smooth

The smoouth tangent which contains the inflection between P:Microsoft.Xna.Framework.CurveKey.TangentIn and P:Microsoft.Xna.Framework.CurveKey.TangentOut by taking into account the values of both neighbors of the T:Microsoft.Xna.Framework.CurveKey.

DepthFormat

enum DepthFormat : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines formats for depth-stencil buffer.

DepthFormat None

Depth-stencil buffer will not be created.

DepthFormat Depth16

16-bit depth buffer.

DepthFormat Depth24

24-bit depth buffer. Equivalent of F:Microsoft.Xna.Framework.Graphics.DepthFormat.Depth24Stencil8 for DirectX platforms.

DepthFormat Depth24Stencil8

32-bit depth-stencil buffer. Where 24-bit depth and 8-bit for stencil used.

DepthStencilState

class DepthStencilState : GraphicsResource, System.IDisposable

DepthStencilState Default

DepthStencilState DepthRead

DepthStencilState None

bool DepthBufferEnable

bool DepthBufferWriteEnable

StencilOperation CounterClockwiseStencilDepthBufferFail

StencilOperation CounterClockwiseStencilFail

CompareFunction CounterClockwiseStencilFunction

StencilOperation CounterClockwiseStencilPass

CompareFunction DepthBufferFunction

int ReferenceStencil

StencilOperation StencilDepthBufferFail

bool StencilEnable

StencilOperation StencilFail

CompareFunction StencilFunction

int StencilMask

StencilOperation StencilPass

int StencilWriteMask

bool TwoSidedStencilMode

void BindToGraphicsDevice(GraphicsDevice device)

Parameters:

• device (Microsoft.Xna.Framework.Graphics.GraphicsDevice) –

void ThrowIfBound()

DepthStencilState Clone()

void GraphicsDeviceResetting()

void PlatformApplyState(GraphicsDevice device)

Parameters:

• device (Microsoft.Xna.Framework.Graphics.GraphicsDevice) –

DeviceLostException

class DeviceLostException : System.Exception, System.Runtime.Serialization.ISerializable, System.Runtime.InteropServices._Exception

DeviceNotResetException

class DeviceNotResetException : System.Exception, System.Runtime.Serialization.ISerializable, System.Runtime.InteropServices._Exception

DirectionalLight

class DirectionalLight : System.Object

Vector3 DiffuseColor

Vector3 Direction

Vector3 SpecularColor

bool Enabled

DisplayMode

class DisplayMode : System.Object

readonly float AspectRatio

readonly SurfaceFormat Format

readonly int Height

readonly int Width

readonly Rectangle TitleSafeArea

public bool op_Inequality(DisplayMode left, DisplayMode right)

Parameters:

• left (Microsoft.Xna.Framework.Graphics.DisplayMode) –
• right (Microsoft.Xna.Framework.Graphics.DisplayMode) –

public bool op_Equality(DisplayMode left, DisplayMode right)

Parameters:

• left (Microsoft.Xna.Framework.Graphics.DisplayMode) –
• right (Microsoft.Xna.Framework.Graphics.DisplayMode) –

public bool Equals(System.Object obj)

Parameters:

• obj (System.Object) –

public int GetHashCode()

public string ToString()

DisplayModeCollection

class DisplayModeCollection : System.Object, System.Collections.Generic.IEnumerable<DisplayMode>, System.Collections.IEnumerable

readonly System.Collections.Generic.IEnumerable<DisplayMode> Item

public System.Collections.Generic.IEnumerator<DisplayMode> GetEnumerator()

DisplayOrientation

enum DisplayOrientation : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines the orientation of the display.

DisplayOrientation Default

The default orientation.

DisplayOrientation LandscapeLeft

The display is rotated counterclockwise into a landscape orientation. Width is greater than height.

DisplayOrientation LandscapeRight

The display is rotated clockwise into a landscape orientation. Width is greater than height.

DisplayOrientation Portrait

The display is rotated as portrait, where height is greater than width.

DisplayOrientation PortraitDown

The display is rotated as inverted portrait, where height is greater than width.

DisplayOrientation Unknown

Unknown display orientation.

DrawableGameComponent

class DrawableGameComponent : GameComponent, IGameComponent, IUpdateable, System.IComparable<GameComponent>, System.IDisposable, IDrawable

readonly GraphicsDevice GraphicsDevice

int DrawOrder

bool Visible

public void add_DrawOrderChanged(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_DrawOrderChanged(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void add_VisibleChanged(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_VisibleChanged(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void Initialize()

public void Draw(GameTime gameTime)

Parameters:

• gameTime (Microsoft.Xna.Framework.GameTime) –

DualTextureEffect

class DualTextureEffect : Effect, System.IDisposable, IEffectMatrices, IEffectFog

Built-in effect that supports two-layer multitexturing.

Matrix World

Gets or sets the world matrix.

Matrix View

Gets or sets the view matrix.

Matrix Projection

Gets or sets the projection matrix.

Vector3 DiffuseColor

Gets or sets the material diffuse color (range 0 to 1).

float Alpha

Gets or sets the material alpha.

bool FogEnabled

Gets or sets the fog enable flag.

float FogStart

Gets or sets the fog start distance.

float FogEnd

Gets or sets the fog end distance.

Vector3 FogColor

Gets or sets the fog color.

Texture2D Texture

Gets or sets the current base texture.

Texture2D Texture2

Gets or sets the current overlay texture.

bool VertexColorEnabled

Gets or sets whether vertex color is enabled.

public Effect Clone()

Creates a clone of the current DualTextureEffect instance.

void OnApply()

Lazily computes derived parameter values immediately before applying the effect.

DynamicIndexBuffer

class DynamicIndexBuffer : IndexBuffer, System.IDisposable

readonly bool IsContentLost

public void SetData<T>(int offsetInBytes, Microsoft.Xna.Framework.Graphics.T[] data, int startIndex, int elementCount, SetDataOptions options)

Type Parameters:  

• T –

Parameters:

• offsetInBytes (int) –
• data (Microsoft.Xna.Framework.Graphics.T[]) –
• startIndex (int) –
• elementCount (int) –
• options (Microsoft.Xna.Framework.Graphics.SetDataOptions) –

public void SetData<T>(Microsoft.Xna.Framework.Graphics.T[] data, int startIndex, int elementCount, SetDataOptions options)

Type Parameters:  

• T –

Parameters:

• data (Microsoft.Xna.Framework.Graphics.T[]) –
• startIndex (int) –
• elementCount (int) –
• options (Microsoft.Xna.Framework.Graphics.SetDataOptions) –

DynamicSoundEffectInstance

class DynamicSoundEffectInstance : SoundEffectInstance, System.IDisposable

A T:Microsoft.Xna.Framework.Audio.SoundEffectInstance for which the audio buffer is provided by the game at run time.

bool IsLooped

This value has no effect on DynamicSoundEffectInstance. It may not be set.

readonly SoundState State

readonly int PendingBufferCount

Returns the number of audio buffers queued for playback.

public void add_BufferNeeded(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_BufferNeeded(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public System.TimeSpan GetSampleDuration(int sizeInBytes)

Returns the duration of an audio buffer of the specified size, based on the settings of this instance.

Parameters:

• sizeInBytes (int) – Size of the buffer, in bytes.

Returns:

The playback length of the buffer.

public int GetSampleSizeInBytes(System.TimeSpan duration)

Returns the size, in bytes, of a buffer of the specified duration, based on the settings of this instance.

Parameters:

• duration (System.TimeSpan) – The playback length of the buffer.

Returns:

The data size of the buffer, in bytes.

public void Play()

Plays or resumes the DynamicSoundEffectInstance.

public void Pause()

Pauses playback of the DynamicSoundEffectInstance.

public void Resume()

Resumes playback of the DynamicSoundEffectInstance.

public void Stop()

Immediately stops playing the DynamicSoundEffectInstance.

public void Stop(bool immediate)

Stops playing the DynamicSoundEffectInstance. If the parameter is false, this call has no effect.

Parameters:

• immediate (bool) – When set to false, this call has no effect.

public void SubmitBuffer(System.Byte[] buffer)

Queues an audio buffer for playback.

Parameters:

• buffer (System.Byte[]) – The buffer containing PCM audio data.

public void SubmitBuffer(System.Byte[] buffer, int offset, int count)

Queues an audio buffer for playback.

Parameters:

• buffer (System.Byte[]) – The buffer containing PCM audio data.
• offset (int) – The starting position of audio data.
• count (int) – The amount of bytes to use.

void UpdateQueue()

DynamicVertexBuffer

class DynamicVertexBuffer : VertexBuffer, System.IDisposable

readonly bool IsContentLost

public void SetData<T>(int offsetInBytes, Microsoft.Xna.Framework.Graphics.T[] data, int startIndex, int elementCount, int vertexStride, SetDataOptions options)

Type Parameters:  

• T –

Parameters:

• offsetInBytes (int) –
• data (Microsoft.Xna.Framework.Graphics.T[]) –
• startIndex (int) –
• elementCount (int) –
• vertexStride (int) –
• options (Microsoft.Xna.Framework.Graphics.SetDataOptions) –

public void SetData<T>(Microsoft.Xna.Framework.Graphics.T[] data, int startIndex, int elementCount, SetDataOptions options)

Type Parameters:  

• T –

Parameters:

• data (Microsoft.Xna.Framework.Graphics.T[]) –
• startIndex (int) –
• elementCount (int) –
• options (Microsoft.Xna.Framework.Graphics.SetDataOptions) –

Effect

class Effect : GraphicsResource, System.IDisposable

readonly EffectParameterCollection Parameters

readonly EffectTechniqueCollection Techniques

EffectTechnique CurrentTechnique

Microsoft.Xna.Framework.Graphics.ConstantBuffer[] get_ConstantBuffers()

public Effect Clone()

Returns a deep copy of the effect where immutable types are shared and mutable data is duplicated.

Returns:The cloned effect.

void OnApply()

void GraphicsDeviceResetting()

EffectAnnotation

class EffectAnnotation : System.Object

readonly EffectParameterClass ParameterClass

readonly EffectParameterType ParameterType

readonly string Name

readonly int RowCount

readonly int ColumnCount

readonly string Semantic

EffectAnnotationCollection

class EffectAnnotationCollection : System.Object, System.Collections.Generic.IEnumerable<EffectAnnotation>, System.Collections.IEnumerable

readonly int Count

readonly EffectAnnotation Item

readonly EffectAnnotation Item

public System.Collections.Generic.IEnumerator<EffectAnnotation> GetEnumerator()

EffectMaterial

class EffectMaterial : Effect, System.IDisposable

EffectParameter

class EffectParameter : System.Object

readonly string Name

readonly string Semantic

readonly EffectParameterClass ParameterClass

readonly EffectParameterType ParameterType

readonly int RowCount

readonly int ColumnCount

readonly EffectParameterCollection Elements

readonly EffectParameterCollection StructureMembers

readonly EffectAnnotationCollection Annotations

ulong get_NextStateKey()

System.Object get_Data()

ulong get_StateKey()

public bool GetValueBoolean()

public int GetValueInt32()

public Matrix GetValueMatrix()

public Microsoft.Xna.Framework.Matrix[] GetValueMatrixArray(int count)

Parameters:

• count (int) –

public Quaternion GetValueQuaternion()

public float GetValueSingle()

public System.Single[] GetValueSingleArray()

public string GetValueString()

public Texture2D GetValueTexture2D()

public Texture3D GetValueTexture3D()

public TextureCube GetValueTextureCube()

public Vector2 GetValueVector2()

public Microsoft.Xna.Framework.Vector2[] GetValueVector2Array()

public Vector3 GetValueVector3()

public Microsoft.Xna.Framework.Vector3[] GetValueVector3Array()

public Vector4 GetValueVector4()

public Microsoft.Xna.Framework.Vector4[] GetValueVector4Array()

public void SetValue(bool value)

Parameters:

• value (bool) –

public void SetValue(int value)

Parameters:

• value (int) –

public void SetValue(Matrix value)

Parameters:

• value (Microsoft.Xna.Framework.Matrix) –

public void SetValueTranspose(Matrix value)

Parameters:

• value (Microsoft.Xna.Framework.Matrix) –

public void SetValue(Microsoft.Xna.Framework.Matrix[] value)

Parameters:

• value (Microsoft.Xna.Framework.Matrix[]) –

public void SetValue(Quaternion value)

Parameters:

• value (Microsoft.Xna.Framework.Quaternion) –

public void SetValue(float value)

Parameters:

• value (float) –

public void SetValue(System.Single[] value)

Parameters:

• value (System.Single[]) –

public void SetValue(Texture value)

Parameters:

• value (Microsoft.Xna.Framework.Graphics.Texture) –

public void SetValue(Vector2 value)

Parameters:

• value (Microsoft.Xna.Framework.Vector2) –

public void SetValue(Microsoft.Xna.Framework.Vector2[] value)

Parameters:

• value (Microsoft.Xna.Framework.Vector2[]) –

public void SetValue(Vector3 value)

Parameters:

• value (Microsoft.Xna.Framework.Vector3) –

public void SetValue(Microsoft.Xna.Framework.Vector3[] value)

Parameters:

• value (Microsoft.Xna.Framework.Vector3[]) –

public void SetValue(Vector4 value)

Parameters:

• value (Microsoft.Xna.Framework.Vector4) –

public void SetValue(Microsoft.Xna.Framework.Vector4[] value)

Parameters:

• value (Microsoft.Xna.Framework.Vector4[]) –

EffectParameterClass

enum EffectParameterClass : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines classes for effect parameters and shader constants.

EffectParameterClass Scalar

Scalar class type.

EffectParameterClass Vector

Vector class type.

EffectParameterClass Matrix

Matrix class type.

EffectParameterClass Object

Class type for textures, shaders or strings.

EffectParameterClass Struct

Structure class type.

EffectParameterCollection

class EffectParameterCollection : System.Object, System.Collections.Generic.IEnumerable<EffectParameter>, System.Collections.IEnumerable

readonly int Count

readonly EffectParameter Item

readonly EffectParameter Item

EffectParameterCollection Clone()

public System.Collections.Generic.IEnumerator<EffectParameter> GetEnumerator()

EffectParameterType

enum EffectParameterType : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines types for effect parameters and shader constants.

EffectParameterType Void

Pointer to void type.

EffectParameterType Bool

Boolean type. Any non-zero will be true; false otherwise.

EffectParameterType Int32

32-bit integer type.

EffectParameterType Single

Float type.

EffectParameterType String

String type.

EffectParameterType Texture

Any texture type.

EffectParameterType Texture1D

1D-texture type.

EffectParameterType Texture2D

2D-texture type.

EffectParameterType Texture3D

3D-texture type.

EffectParameterType TextureCube

Cubic texture type.

EffectPass

class EffectPass : System.Object

readonly string Name

readonly EffectAnnotationCollection Annotations

public void Apply()

EffectPassCollection

class EffectPassCollection : System.Object, System.Collections.Generic.IEnumerable<EffectPass>, System.Collections.IEnumerable

readonly EffectPass Item

readonly EffectPass Item

readonly int Count

EffectPassCollection Clone(Effect effect)

Parameters:

• effect (Microsoft.Xna.Framework.Graphics.Effect) –

public Microsoft.Xna.Framework.Graphics.Enumerator GetEnumerator()

EffectTechnique

class EffectTechnique : System.Object

readonly EffectPassCollection Passes

readonly EffectAnnotationCollection Annotations

readonly string Name

EffectTechniqueCollection

class EffectTechniqueCollection : System.Object, System.Collections.Generic.IEnumerable<EffectTechnique>, System.Collections.IEnumerable

readonly int Count

readonly EffectTechnique Item

readonly EffectTechnique Item

EffectTechniqueCollection Clone(Effect effect)

Parameters:

• effect (Microsoft.Xna.Framework.Graphics.Effect) –

public System.Collections.Generic.IEnumerator<EffectTechnique> GetEnumerator()

EnvironmentMapEffect

class EnvironmentMapEffect : Effect, System.IDisposable, IEffectMatrices, IEffectLights, IEffectFog

Built-in effect that supports environment mapping.

Matrix World

Gets or sets the world matrix.

Matrix View

Gets or sets the view matrix.

Matrix Projection

Gets or sets the projection matrix.

Vector3 DiffuseColor

Gets or sets the material diffuse color (range 0 to 1).

Vector3 EmissiveColor

Gets or sets the material emissive color (range 0 to 1).

float Alpha

Gets or sets the material alpha.

Vector3 AmbientLightColor

Gets or sets the ambient light color (range 0 to 1).

readonly DirectionalLight DirectionalLight0

Gets the first directional light.

readonly DirectionalLight DirectionalLight1

Gets the second directional light.

readonly DirectionalLight DirectionalLight2

Gets the third directional light.

bool FogEnabled

Gets or sets the fog enable flag.

float FogStart

Gets or sets the fog start distance.

float FogEnd

Gets or sets the fog end distance.

Vector3 FogColor

Gets or sets the fog color.

Texture2D Texture

Gets or sets the current texture.

TextureCube EnvironmentMap

Gets or sets the current environment map texture.

float EnvironmentMapAmount

Gets or sets the amount of the environment map RGB that will be blended over the base texture. Range 0 to 1, default 1. If set to zero, the RGB channels of the environment map will completely ignored (but the environment map alpha may still be visible if EnvironmentMapSpecular is greater than zero).

Vector3 EnvironmentMapSpecular

Gets or sets the amount of the environment map alpha channel that will be added to the base texture. Range 0 to 1, default 0. This can be used to implement cheap specular lighting, by encoding one or more specular highlight patterns into the environment map alpha channel, then setting EnvironmentMapSpecular to the desired specular light color.

float FresnelFactor

Gets or sets the Fresnel factor used for the environment map blending. Higher values make the environment map only visible around the silhouette edges of the object, while lower values make it visible everywhere. Setting this property to 0 disables Fresnel entirely, making the environment map equally visible regardless of view angle. The default is 1. Fresnel only affects the environment map RGB (the intensity of which is controlled by EnvironmentMapAmount). The alpha contribution (controlled by EnvironmentMapSpecular) is not affected by the Fresnel setting.

public Effect Clone()

Creates a clone of the current EnvironmentMapEffect instance.

public void EnableDefaultLighting()

Sets up the standard key/fill/back lighting rig.

void OnApply()

Lazily computes derived parameter values immediately before applying the effect.

FillMode

enum FillMode : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines options for filling the primitive.

FillMode Solid

Draw solid faces for each primitive.

FillMode WireFrame

Draw lines for each primitive.

FlushType

enum FlushType : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Describes how to flush the current deflate operation.

FlushType None

No flush at all.

FlushType Partial

Closes the current block, but doesn’t flush it to

the output. Used internally only in hypothetical scenarios. This was supposed to be removed by Zlib, but it is still in use in some edge cases.

FlushType Sync

Use this during compression to specify that all pending output should be flushed to the output buffer and the output should be aligned on a byte boundary. You might use this in a streaming communication scenario, so that the decompressor can get all input data available so far. When using this with a ZlibCodec, AvailableBytesIn will be zero after the call if enough output space has been provided before the call. Flushing will degrade compression and so it should be used only when necessary.

FlushType Full

Use this during compression to specify that all output should be flushed, as with FlushType.Sync, but also, the compression state should be reset so that decompression can restart from this point if previous compressed data has been damaged or if random access is desired. Using FlushType.Full too often can significantly degrade the compression.

FlushType Finish

Signals the end of the compression/decompression stream.

FrameworkDispatcher

class FrameworkDispatcher : System.Object

Helper class for processing internal framework events.

public void Update()

Processes framework events.

Game

class Game : System.Object, System.IDisposable

readonly LaunchParameters LaunchParameters

readonly GameComponentCollection Components

System.TimeSpan InactiveSleepTime

System.TimeSpan MaxElapsedTime

The maximum amount of time we will frameskip over and only perform Update calls with no Draw calls. MonoGame extension.

readonly bool IsActive

bool IsMouseVisible

System.TimeSpan TargetElapsedTime

bool IsFixedTimeStep

readonly GameServiceContainer Services

ContentManager Content

readonly GraphicsDevice GraphicsDevice

readonly GameWindow Window

void Log(string Message)

Parameters:

• Message (string) –

public void Dispose()

Game get_Instance()

bool get_Initialized()

public void add_Activated(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_Activated(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void add_Deactivated(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_Deactivated(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void add_Disposed(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_Disposed(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void add_Exiting(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_Exiting(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void Exit()

public void ResetElapsedTime()

public void SuppressDraw()

public void RunOneFrame()

public void Run()

public void Run(GameRunBehavior runBehavior)

Parameters:

• runBehavior (Microsoft.Xna.Framework.GameRunBehavior) –

public void Tick()

void applyChanges(GraphicsDeviceManager manager)

Parameters:

• manager (Microsoft.Xna.Framework.GraphicsDeviceManager) –

void DoUpdate(GameTime gameTime)

Parameters:

• gameTime (Microsoft.Xna.Framework.GameTime) –

void DoDraw(GameTime gameTime)

Parameters:

• gameTime (Microsoft.Xna.Framework.GameTime) –

void DoInitialize()

void DoExiting()

GraphicsDeviceManager get_graphicsDeviceManager()

GameComponent

class GameComponent : System.Object, IGameComponent, IUpdateable, System.IComparable<GameComponent>, System.IDisposable

readonly Game Game

bool Enabled

int UpdateOrder

public void add_EnabledChanged(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_EnabledChanged(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void add_UpdateOrderChanged(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_UpdateOrderChanged(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void Initialize()

public void Update(GameTime gameTime)

Parameters:

• gameTime (Microsoft.Xna.Framework.GameTime) –

public void Dispose()

Shuts down the component.

public int CompareTo(GameComponent other)

Parameters:

• other (Microsoft.Xna.Framework.GameComponent) –

GameComponentCollection

class GameComponentCollection : System.Collections.ObjectModel.Collection<IGameComponent>, System.Collections.Generic.IList<IGameComponent>, System.Collections.Generic.ICollection<IGameComponent>, System.Collections.Generic.IEnumerable<IGameComponent>, System.Collections.IEnumerable, System.Collections.IList, System.Collections.ICollection, System.Collections.Generic.IReadOnlyList<IGameComponent>, System.Collections.Generic.IReadOnlyCollection<IGameComponent>

public void add_ComponentAdded(System.EventHandler<GameComponentCollectionEventArgs> value)

Parameters:

• value (System.EventHandler<GameComponentCollectionEventArgs>) –

public void remove_ComponentAdded(System.EventHandler<GameComponentCollectionEventArgs> value)

Parameters:

• value (System.EventHandler<GameComponentCollectionEventArgs>) –

public void add_ComponentRemoved(System.EventHandler<GameComponentCollectionEventArgs> value)

Parameters:

• value (System.EventHandler<GameComponentCollectionEventArgs>) –

public void remove_ComponentRemoved(System.EventHandler<GameComponentCollectionEventArgs> value)

Parameters:

• value (System.EventHandler<GameComponentCollectionEventArgs>) –

GameComponentCollectionEventArgs

class GameComponentCollectionEventArgs : System.EventArgs

readonly IGameComponent GameComponent

GamePad

class GamePad : System.Object

Supports querying the game controllers and setting the vibration motors.

readonly int MaximumGamePadCount

The maximum number of game pads supported on this system. Attempting to access a gamepad index higher than this number will result in an T:System.InvalidOperationException being thrown by the API.

public GamePadCapabilities GetCapabilities(PlayerIndex playerIndex)

Returns the capabilites of the connected controller.

Parameters:

• playerIndex (Microsoft.Xna.Framework.PlayerIndex) – Player index for the controller you want to query.

Returns:

The capabilites of the controller.

public GamePadCapabilities GetCapabilities(int index)

Returns the capabilites of the connected controller.

Parameters:

• index (int) – Index for the controller you want to query.

Returns:

The capabilites of the controller.

public GamePadState GetState(PlayerIndex playerIndex)

Gets the current state of a game pad controller with an independent axes dead zone.

Parameters:

• playerIndex (Microsoft.Xna.Framework.PlayerIndex) – Player index for the controller you want to query.

Returns:

The state of the controller.

public GamePadState GetState(int index)

Gets the current state of a game pad controller with an independent axes dead zone.

Parameters:

• index (int) – Index for the controller you want to query.

Returns:

The state of the controller.

public GamePadState GetState(PlayerIndex playerIndex, GamePadDeadZone deadZoneMode)

Gets the current state of a game pad controller, using a specified dead zone on analog stick positions.

Parameters:

• playerIndex (Microsoft.Xna.Framework.PlayerIndex) – Player index for the controller you want to query.
• deadZoneMode (Microsoft.Xna.Framework.Input.GamePadDeadZone) – Enumerated value that specifies what dead zone type to use.

Returns:

The state of the controller.

public GamePadState GetState(int index, GamePadDeadZone deadZoneMode)

Gets the current state of a game pad controller, using a specified dead zone on analog stick positions.

Parameters:

• index (int) – Index for the controller you want to query.
• deadZoneMode (Microsoft.Xna.Framework.Input.GamePadDeadZone) – Enumerated value that specifies what dead zone type to use.

Returns:

The state of the controller.

public bool SetVibration(PlayerIndex playerIndex, float leftMotor, float rightMotor)

Sets the vibration motor speeds on the controller device if supported.

Parameters:

• playerIndex (Microsoft.Xna.Framework.PlayerIndex) – Player index that identifies the controller to set.
• leftMotor (float) – The speed of the left motor, between 0.0 and 1.0. This motor is a low-frequency motor.
• rightMotor (float) – The speed of the right motor, between 0.0 and 1.0. This motor is a high-frequency motor.

Returns:

Returns true if the vibration motors were set.

public bool SetVibration(int index, float leftMotor, float rightMotor)

Sets the vibration motor speeds on the controller device if supported.

Parameters:

• index (int) – Index for the controller you want to query.
• leftMotor (float) – The speed of the left motor, between 0.0 and 1.0. This motor is a low-frequency motor.
• rightMotor (float) – The speed of the right motor, between 0.0 and 1.0. This motor is a high-frequency motor.

Returns:

Returns true if the vibration motors were set.

GamePadButtons

struct GamePadButtons : System.ValueType

readonly ButtonState A

readonly ButtonState B

readonly ButtonState Back

readonly ButtonState X

readonly ButtonState Y

readonly ButtonState Start

readonly ButtonState LeftShoulder

readonly ButtonState LeftStick

readonly ButtonState RightShoulder

readonly ButtonState RightStick

readonly ButtonState BigButton

bool op_Equality(GamePadButtons left, GamePadButtons right)

Determines whether two specified instances of T:Microsoft.Xna.Framework.Input.GamePadButtons are equal.

Parameters:

• left (Microsoft.Xna.Framework.Input.GamePadButtons) – The first object to compare.
• right (Microsoft.Xna.Framework.Input.GamePadButtons) – The second object to compare.

Returns:

true if and are equal; otherwise, false.

bool op_Inequality(GamePadButtons left, GamePadButtons right)

Determines whether two specified instances of T:Microsoft.Xna.Framework.Input.GamePadButtons are not equal.

Parameters:

• left (Microsoft.Xna.Framework.Input.GamePadButtons) – The first object to compare.
• right (Microsoft.Xna.Framework.Input.GamePadButtons) – The second object to compare.

Returns:

true if and are not equal; otherwise, false.

bool Equals(System.Object obj)

Returns a value indicating whether this instance is equal to a specified object.

Parameters:

• obj (System.Object) – An object to compare to this instance.

Returns:

true if is a T:Microsoft.Xna.Framework.Input.GamePadButtons and has the same value as this instance; otherwise, false.

int GetHashCode()

GamePadCapabilities

struct GamePadCapabilities : System.ValueType

readonly bool IsConnected

readonly bool HasAButton

readonly bool HasBackButton

readonly bool HasBButton

readonly bool HasDPadDownButton

readonly bool HasDPadLeftButton

readonly bool HasDPadRightButton

readonly bool HasDPadUpButton

readonly bool HasLeftShoulderButton

readonly bool HasLeftStickButton

readonly bool HasRightShoulderButton

readonly bool HasRightStickButton

readonly bool HasStartButton

readonly bool HasXButton

readonly bool HasYButton

readonly bool HasBigButton

readonly bool HasLeftXThumbStick

readonly bool HasLeftYThumbStick

readonly bool HasRightXThumbStick

readonly bool HasRightYThumbStick

readonly bool HasLeftTrigger

readonly bool HasRightTrigger

readonly bool HasLeftVibrationMotor

readonly bool HasRightVibrationMotor

readonly bool HasVoiceSupport

readonly GamePadType GamePadType

void set_IsConnected(bool value)

Parameters:

• value (bool) –

void set_HasAButton(bool value)

Parameters:

• value (bool) –

void set_HasBackButton(bool value)

Parameters:

• value (bool) –

void set_HasBButton(bool value)

Parameters:

• value (bool) –

void set_HasDPadDownButton(bool value)

Parameters:

• value (bool) –

void set_HasDPadLeftButton(bool value)

Parameters:

• value (bool) –

void set_HasDPadRightButton(bool value)

Parameters:

• value (bool) –

void set_HasDPadUpButton(bool value)

Parameters:

• value (bool) –

void set_HasLeftShoulderButton(bool value)

Parameters:

• value (bool) –

void set_HasLeftStickButton(bool value)

Parameters:

• value (bool) –

void set_HasRightShoulderButton(bool value)

Parameters:

• value (bool) –

void set_HasRightStickButton(bool value)

Parameters:

• value (bool) –

void set_HasStartButton(bool value)

Parameters:

• value (bool) –

void set_HasXButton(bool value)

Parameters:

• value (bool) –

void set_HasYButton(bool value)

Parameters:

• value (bool) –

void set_HasBigButton(bool value)

Parameters:

• value (bool) –

void set_HasLeftXThumbStick(bool value)

Parameters:

• value (bool) –

void set_HasLeftYThumbStick(bool value)

Parameters:

• value (bool) –

void set_HasRightXThumbStick(bool value)

Parameters:

• value (bool) –

void set_HasRightYThumbStick(bool value)

Parameters:

• value (bool) –

void set_HasLeftTrigger(bool value)

Parameters:

• value (bool) –

void set_HasRightTrigger(bool value)

Parameters:

• value (bool) –

void set_HasLeftVibrationMotor(bool value)

Parameters:

• value (bool) –

void set_HasRightVibrationMotor(bool value)

Parameters:

• value (bool) –

void set_HasVoiceSupport(bool value)

Parameters:

• value (bool) –

void set_GamePadType(GamePadType value)

Parameters:

• value (Microsoft.Xna.Framework.Input.GamePadType) –

GamePadDeadZone

enum GamePadDeadZone : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

GamePadDeadZone None

GamePadDeadZone IndependentAxes

GamePadDeadZone Circular

GamePadDPad

struct GamePadDPad : System.ValueType

readonly ButtonState Down

readonly ButtonState Left

readonly ButtonState Right

readonly ButtonState Up

void set_Down(ButtonState value)

Parameters:

• value (Microsoft.Xna.Framework.Input.ButtonState) –

void set_Left(ButtonState value)

Parameters:

• value (Microsoft.Xna.Framework.Input.ButtonState) –

void set_Right(ButtonState value)

Parameters:

• value (Microsoft.Xna.Framework.Input.ButtonState) –

void set_Up(ButtonState value)

Parameters:

• value (Microsoft.Xna.Framework.Input.ButtonState) –

bool op_Equality(GamePadDPad left, GamePadDPad right)

Determines whether two specified instances of T:Microsoft.Xna.Framework.Input.GamePadDPad are equal.

Parameters:

• left (Microsoft.Xna.Framework.Input.GamePadDPad) – The first object to compare.
• right (Microsoft.Xna.Framework.Input.GamePadDPad) – The second object to compare.

Returns:

true if and are equal; otherwise, false.

bool op_Inequality(GamePadDPad left, GamePadDPad right)

Determines whether two specified instances of T:Microsoft.Xna.Framework.Input.GamePadDPad are not equal.

Parameters:

• left (Microsoft.Xna.Framework.Input.GamePadDPad) – The first object to compare.
• right (Microsoft.Xna.Framework.Input.GamePadDPad) – The second object to compare.

Returns:

true if and are not equal; otherwise, false.

bool Equals(System.Object obj)

Returns a value indicating whether this instance is equal to a specified object.

Parameters:

• obj (System.Object) – An object to compare to this instance.

Returns:

true if is a T:Microsoft.Xna.Framework.Input.GamePadDPad and has the same value as this instance; otherwise, false.

int GetHashCode()

GamePadState

struct GamePadState : System.ValueType

GamePadState Default

The default initialized gamepad state.

readonly bool IsConnected

readonly int PacketNumber

readonly GamePadButtons Buttons

readonly GamePadDPad DPad

readonly GamePadThumbSticks ThumbSticks

readonly GamePadTriggers Triggers

void set_IsConnected(bool value)

Parameters:

• value (bool) –

void set_PacketNumber(int value)

Parameters:

• value (int) –

void set_Buttons(GamePadButtons value)

Parameters:

• value (Microsoft.Xna.Framework.Input.GamePadButtons) –

void set_DPad(GamePadDPad value)

Parameters:

• value (Microsoft.Xna.Framework.Input.GamePadDPad) –

void set_ThumbSticks(GamePadThumbSticks value)

Parameters:

• value (Microsoft.Xna.Framework.Input.GamePadThumbSticks) –

void set_Triggers(GamePadTriggers value)

Parameters:

• value (Microsoft.Xna.Framework.Input.GamePadTriggers) –

bool IsButtonDown(Buttons button)

Parameters:

• button (Microsoft.Xna.Framework.Input.Buttons) –

bool IsButtonUp(Buttons button)

Parameters:

• button (Microsoft.Xna.Framework.Input.Buttons) –

bool op_Inequality(GamePadState left, GamePadState right)

Parameters:

• left (Microsoft.Xna.Framework.Input.GamePadState) –
• right (Microsoft.Xna.Framework.Input.GamePadState) –

bool op_Equality(GamePadState left, GamePadState right)

Parameters:

• left (Microsoft.Xna.Framework.Input.GamePadState) –
• right (Microsoft.Xna.Framework.Input.GamePadState) –

bool Equals(System.Object obj)

Parameters:

• obj (System.Object) –

int GetHashCode()

string ToString()

GamePadThumbSticks

struct GamePadThumbSticks : System.ValueType

readonly Vector2 Left

readonly Vector2 Right

Buttons get_VirtualButtons()

bool op_Equality(GamePadThumbSticks left, GamePadThumbSticks right)

Determines whether two specified instances of T:Microsoft.Xna.Framework.Input.GamePadThumbSticks are equal.

Parameters:

• left (Microsoft.Xna.Framework.Input.GamePadThumbSticks) – The first object to compare.
• right (Microsoft.Xna.Framework.Input.GamePadThumbSticks) – The second object to compare.

Returns:

true if and are equal; otherwise, false.

bool op_Inequality(GamePadThumbSticks left, GamePadThumbSticks right)

Determines whether two specified instances of T:Microsoft.Xna.Framework.Input.GamePadThumbSticks are not equal.

Parameters:

• left (Microsoft.Xna.Framework.Input.GamePadThumbSticks) – The first object to compare.
• right (Microsoft.Xna.Framework.Input.GamePadThumbSticks) – The second object to compare.

Returns:

true if and are not equal; otherwise, false.

bool Equals(System.Object obj)

Returns a value indicating whether this instance is equal to a specified object.

Parameters:

• obj (System.Object) – An object to compare to this instance.

Returns:

true if is a T:Microsoft.Xna.Framework.Input.GamePadThumbSticks and has the same value as this instance; otherwise, false.

int GetHashCode()

GamePadTriggers

struct GamePadTriggers : System.ValueType

readonly float Left

readonly float Right

void set_Left(float value)

Parameters:

• value (float) –

void set_Right(float value)

Parameters:

• value (float) –

bool op_Equality(GamePadTriggers left, GamePadTriggers right)

Determines whether two specified instances of T:Microsoft.Xna.Framework.Input.GamePadTriggers are equal.

Parameters:

• left (Microsoft.Xna.Framework.Input.GamePadTriggers) – The first object to compare.
• right (Microsoft.Xna.Framework.Input.GamePadTriggers) – The second object to compare.

Returns:

true if and are equal; otherwise, false.

bool op_Inequality(GamePadTriggers left, GamePadTriggers right)

Determines whether two specified instances of T:Microsoft.Xna.Framework.Input.GamePadTriggers are not equal.

Parameters:

• left (Microsoft.Xna.Framework.Input.GamePadTriggers) – The first object to compare.
• right (Microsoft.Xna.Framework.Input.GamePadTriggers) – The second object to compare.

Returns:

true if and are not equal; otherwise, false.

bool Equals(System.Object obj)

Returns a value indicating whether this instance is equal to a specified object.

Parameters:

• obj (System.Object) – An object to compare to this instance.

Returns:

true if is a T:Microsoft.Xna.Framework.Input.GamePadTriggers and has the same value as this instance; otherwise, false.

int GetHashCode()

GamePadType

enum GamePadType : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines a type of gamepad.

GamePadType Unknown

Unknown.

GamePadType GamePad

GamePad is the XBOX controller.

GamePadType Wheel

GamePad is a wheel.

GamePadType ArcadeStick

GamePad is an arcade stick.

GamePadType FlightStick

GamePad is a flight stick.

GamePadType DancePad

GamePad is a dance pad.

GamePadType Guitar

GamePad is a guitar.

GamePadType AlternateGuitar

GamePad is an alternate guitar.

GamePadType DrumKit

GamePad is a drum kit.

GamePadType BigButtonPad

GamePad is a big button pad.

GameRunBehavior

enum GameRunBehavior : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines how T:Microsoft.Xna.Framework.Game should be runned.

GameRunBehavior Asynchronous

The game loop will be runned asynchronous.

GameRunBehavior Synchronous

The game loop will be runned synchronous.

GameServiceContainer

class GameServiceContainer : System.Object, System.IServiceProvider

public void AddService(System.Type type, System.Object provider)

Parameters:

• type (System.Type) –
• provider (System.Object) –

public System.Object GetService(System.Type type)

Parameters:

• type (System.Type) –

public void RemoveService(System.Type type)

Parameters:

• type (System.Type) –

public void AddService<T>(Microsoft.Xna.Framework.T provider)

Type Parameters:  

• T –

Parameters:

• provider (Microsoft.Xna.Framework.T) –

public Microsoft.Xna.Framework.T GetService<T>()

Type Parameters:  

• T –

GameTime

class GameTime : System.Object

System.TimeSpan TotalGameTime

System.TimeSpan ElapsedGameTime

bool IsRunningSlowly

GameUpdateRequiredException

class GameUpdateRequiredException : System.Exception, System.Runtime.Serialization.ISerializable, System.Runtime.InteropServices._Exception

GameWindow

class GameWindow : System.Object

bool AllowUserResizing

readonly Rectangle ClientBounds

bool AllowAltF4

Gets or sets a bool that enables usage of Alt+F4 for window closing on desktop platforms. Value is true by default.

Point Position

The location of this window on the desktop, eg: global coordinate space which stretches across all screens.

readonly DisplayOrientation CurrentOrientation

readonly System.IntPtr Handle

readonly string ScreenDeviceName

string Title

Gets or sets the title of the game window.

bool IsBorderless

Determines whether the border of the window is visible. Currently only supported on the WinDX and WinGL/Linux platforms.

public void add_ClientSizeChanged(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_ClientSizeChanged(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void add_OrientationChanged(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_OrientationChanged(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void add_ScreenDeviceNameChanged(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_ScreenDeviceNameChanged(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void add_TextInput(System.EventHandler<TextInputEventArgs> value)

Parameters:

• value (System.EventHandler<TextInputEventArgs>) –

public void remove_TextInput(System.EventHandler<TextInputEventArgs> value)

Parameters:

• value (System.EventHandler<TextInputEventArgs>) –

public abstract void BeginScreenDeviceChange(bool willBeFullScreen)

Parameters:

• willBeFullScreen (bool) –

public abstract void EndScreenDeviceChange(string screenDeviceName, int clientWidth, int clientHeight)

Parameters:

• screenDeviceName (string) –
• clientWidth (int) –
• clientHeight (int) –

public void EndScreenDeviceChange(string screenDeviceName)

Parameters:

• screenDeviceName (string) –

void OnClientSizeChanged()

abstract void SetSupportedOrientations(DisplayOrientation orientations)

Parameters:

• orientations (Microsoft.Xna.Framework.DisplayOrientation) –

protected abstract void SetTitle(string title)

Parameters:

• title (string) –

public GameWindow Create(Game game, int width, int height)

Parameters:

• game (Microsoft.Xna.Framework.Game) –
• width (int) –
• height (int) –

Genre

class Genre : System.Object, System.IDisposable

readonly AlbumCollection Albums

Gets the AlbumCollection for the Genre.

readonly bool IsDisposed

Gets a value indicating whether the object is disposed.

readonly string Name

Gets the name of the Genre.

readonly SongCollection Songs

Gets the SongCollection for the Genre.

public void Dispose()

Immediately releases the unmanaged resources used by this object.

public string ToString()

Returns a String representation of the Genre.

public int GetHashCode()

Gets the hash code for this instance.

GestureSample

struct GestureSample : System.ValueType

Represents data from a multi-touch gesture over a span of time.

readonly GestureType GestureType

Gets the type of the gesture.

readonly System.TimeSpan Timestamp

Gets the starting time for this multi-touch gesture sample.

readonly Vector2 Position

Gets the position of the first touch-point in the gesture sample.

readonly Vector2 Position2

Gets the position of the second touch-point in the gesture sample.

readonly Vector2 Delta

Gets the delta information for the first touch-point in the gesture sample.

readonly Vector2 Delta2

Gets the delta information for the second touch-point in the gesture sample.

GestureType

enum GestureType : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Enumuration of values that represent different gestures that can be processed by M:Microsoft.Xna.Framework.Input.Touch.TouchPanel.ReadGesture.

GestureType None

No gestures.

GestureType Tap

The user touched a single point.

GestureType DragComplete

States completion of a drag gesture(VerticalDrag, HorizontalDrag, or FreeDrag).

GestureType Flick

States that a touch was combined with a quick swipe.

GestureType FreeDrag

The use touched a point and then performed a free-form drag.

GestureType Hold

The use touched a single point for approximately one second.

GestureType HorizontalDrag

The user touched the screen and performed either left to right or right to left drag gesture.

GestureType Pinch

The user either converged or diverged two touch-points on the screen which is like a two-finger drag.

GestureType PinchComplete

An in-progress pinch operation was completed.

GestureType DoubleTap

The user tapped the device twice which is always preceded by a Tap gesture.

GestureType VerticalDrag

The user touched the screen and performed either top to bottom or bottom to top drag gesture.

GraphicsAdapter

class GraphicsAdapter : System.Object, System.IDisposable

readonly GraphicsAdapter DefaultAdapter

readonly System.Collections.ObjectModel.ReadOnlyCollection<GraphicsAdapter> Adapters

bool UseReferenceDevice

Used to request creation of the reference graphics device, or the default hardware accelerated device (when set to false).

Microsoft.Xna.Framework.Graphics.DriverType UseDriverType

Used to request creation of a specific kind of driver.

readonly string Description

readonly int DeviceId

readonly string DeviceName

readonly int VendorId

readonly bool IsDefaultAdapter

readonly System.IntPtr MonitorHandle

readonly int Revision

readonly int SubSystemId

readonly DisplayModeCollection SupportedDisplayModes

readonly DisplayMode CurrentDisplayMode

readonly bool IsWideScreen

Returns true if the P:Microsoft.Xna.Framework.Graphics.GraphicsAdapter.CurrentDisplayMode is widescreen.

public bool IsProfileSupported(GraphicsProfile graphicsProfile)

Parameters:

• graphicsProfile (Microsoft.Xna.Framework.Graphics.GraphicsProfile) –

public void Dispose()

GraphicsDevice

class GraphicsDevice : System.Object, System.IDisposable

readonly TextureCollection VertexTextures

readonly SamplerStateCollection VertexSamplerStates

readonly TextureCollection Textures

readonly SamplerStateCollection SamplerStates

readonly bool IsDisposed

readonly bool IsContentLost

readonly GraphicsAdapter Adapter

GraphicsMetrics Metrics

The rendering information for debugging and profiling. The metrics are reset every frame after draw within M:Microsoft.Xna.Framework.Graphics.GraphicsDevice.Present.

RasterizerState RasterizerState

Color BlendFactor

The color used as blend factor when alpha blending.

BlendState BlendState

DepthStencilState DepthStencilState

readonly DisplayMode DisplayMode

readonly GraphicsDeviceStatus GraphicsDeviceStatus

readonly PresentationParameters PresentationParameters

Viewport Viewport

readonly GraphicsProfile GraphicsProfile

Rectangle ScissorRectangle

readonly int RenderTargetCount

IndexBuffer Indices

bool ResourcesLost

readonly System.Object Handle

Returns a handle to internal device object. Valid only on DirectX platforms. For usage, convert this to SharpDX.Direct3D11.Device.

void PlatformBeginApplyState()

void PlatformApplyState(bool applyShaders)

Parameters:

• applyShaders (bool) –

public void Flush()

Sends queued-up commands in the command buffer to the graphics processing unit (GPU).

Microsoft.Xna.Framework.Graphics.GraphicsCapabilities get_GraphicsCapabilities()

public void add_DeviceLost(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_DeviceLost(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void add_DeviceReset(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_DeviceReset(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void add_DeviceResetting(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_DeviceResetting(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void add_ResourceCreated(System.EventHandler<ResourceCreatedEventArgs> value)

Parameters:

• value (System.EventHandler<ResourceCreatedEventArgs>) –

public void remove_ResourceCreated(System.EventHandler<ResourceCreatedEventArgs> value)

Parameters:

• value (System.EventHandler<ResourceCreatedEventArgs>) –

public void add_ResourceDestroyed(System.EventHandler<ResourceDestroyedEventArgs> value)

Parameters:

• value (System.EventHandler<ResourceDestroyedEventArgs>) –

public void remove_ResourceDestroyed(System.EventHandler<ResourceDestroyedEventArgs> value)

Parameters:

• value (System.EventHandler<ResourceDestroyedEventArgs>) –

public void add_Disposing(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_Disposing(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

void add_PresentationChanged(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

void remove_PresentationChanged(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

bool get_IsRenderTargetBound()

DepthFormat get_ActiveDepthFormat()

void Initialize()

void ApplyState(bool applyShaders)

Parameters:

• applyShaders (bool) –

public void Clear(Color color)

Parameters:

• color (Microsoft.Xna.Framework.Color) –

public void Clear(ClearOptions options, Color color, float depth, int stencil)

Parameters:

• options (Microsoft.Xna.Framework.Graphics.ClearOptions) –
• color (Microsoft.Xna.Framework.Color) –
• depth (float) –
• stencil (int) –

public void Clear(ClearOptions options, Vector4 color, float depth, int stencil)

Parameters:

• options (Microsoft.Xna.Framework.Graphics.ClearOptions) –
• color (Microsoft.Xna.Framework.Vector4) –
• depth (float) –
• stencil (int) –

public void Dispose()

void AddResourceReference(System.WeakReference resourceReference)

Parameters:

• resourceReference (System.WeakReference) –

void RemoveResourceReference(System.WeakReference resourceReference)

Parameters:

• resourceReference (System.WeakReference) –

public void Present()

public void Reset()

public void Reset(PresentationParameters presentationParameters)

Parameters:

• presentationParameters (Microsoft.Xna.Framework.Graphics.PresentationParameters) –

void OnDeviceResetting()

Trigger the DeviceResetting event Currently internal to allow the various platforms to send the event at the appropriate time.

void OnDeviceReset()

Trigger the DeviceReset event to allow games to be notified of a device reset. Currently internal to allow the various platforms to send the event at the appropriate time.

public void SetRenderTarget(RenderTarget2D renderTarget)

Parameters:

• renderTarget (Microsoft.Xna.Framework.Graphics.RenderTarget2D) –

public void SetRenderTarget(RenderTargetCube renderTarget, CubeMapFace cubeMapFace)

Parameters:

• renderTarget (Microsoft.Xna.Framework.Graphics.RenderTargetCube) –
• cubeMapFace (Microsoft.Xna.Framework.Graphics.CubeMapFace) –

public void SetRenderTargets(Microsoft.Xna.Framework.Graphics.RenderTargetBinding[] renderTargets)

Parameters:

• renderTargets (Microsoft.Xna.Framework.Graphics.RenderTargetBinding[]) –

void ApplyRenderTargets(Microsoft.Xna.Framework.Graphics.RenderTargetBinding[] renderTargets)

Parameters:

• renderTargets (Microsoft.Xna.Framework.Graphics.RenderTargetBinding[]) –

public Microsoft.Xna.Framework.Graphics.RenderTargetBinding[] GetRenderTargets()

public void GetRenderTargets(Microsoft.Xna.Framework.Graphics.RenderTargetBinding[] outTargets)

Parameters:

• outTargets (Microsoft.Xna.Framework.Graphics.RenderTargetBinding[]) –

public void SetVertexBuffer(VertexBuffer vertexBuffer)

Parameters:

• vertexBuffer (Microsoft.Xna.Framework.Graphics.VertexBuffer) –

public void SetVertexBuffer(VertexBuffer vertexBuffer, int vertexOffset)

Parameters:

• vertexBuffer (Microsoft.Xna.Framework.Graphics.VertexBuffer) –
• vertexOffset (int) –

public void SetVertexBuffers(Microsoft.Xna.Framework.Graphics.VertexBufferBinding[] vertexBuffers)

Parameters:

• vertexBuffers (Microsoft.Xna.Framework.Graphics.VertexBufferBinding[]) –

Microsoft.Xna.Framework.Graphics.Shader get_VertexShader()

void set_VertexShader(Microsoft.Xna.Framework.Graphics.Shader value)

Parameters:

• value (Microsoft.Xna.Framework.Graphics.Shader) –

Microsoft.Xna.Framework.Graphics.Shader get_PixelShader()

void set_PixelShader(Microsoft.Xna.Framework.Graphics.Shader value)

Parameters:

• value (Microsoft.Xna.Framework.Graphics.Shader) –

void SetConstantBuffer(ShaderStage stage, int slot, Microsoft.Xna.Framework.Graphics.ConstantBuffer buffer)

Parameters:

• stage (Microsoft.Xna.Framework.Graphics.ShaderStage) –
• slot (int) –
• buffer (Microsoft.Xna.Framework.Graphics.ConstantBuffer) –

public void DrawIndexedPrimitives(PrimitiveType primitiveType, int baseVertex, int minVertexIndex, int numVertices, int startIndex, int primitiveCount)

Draw geometry by indexing into the vertex buffer.

Parameters:

• primitiveType (Microsoft.Xna.Framework.Graphics.PrimitiveType) – The type of primitives in the index buffer.
• baseVertex (int) – Used to offset the vertex range indexed from the vertex buffer.
• minVertexIndex (int) – This is unused and remains here only for XNA API compatibility.
• numVertices (int) – This is unused and remains here only for XNA API compatibility.
• startIndex (int) – The index within the index buffer to start drawing from.
• primitiveCount (int) – The number of primitives to render from the index buffer.

public void DrawIndexedPrimitives(PrimitiveType primitiveType, int baseVertex, int startIndex, int primitiveCount)

Draw geometry by indexing into the vertex buffer.

Parameters:

• primitiveType (Microsoft.Xna.Framework.Graphics.PrimitiveType) – The type of primitives in the index buffer.
• baseVertex (int) – Used to offset the vertex range indexed from the vertex buffer.
• startIndex (int) – The index within the index buffer to start drawing from.
• primitiveCount (int) – The number of primitives to render from the index buffer.

public void DrawUserPrimitives<T>(PrimitiveType primitiveType, Microsoft.Xna.Framework.Graphics.T[] vertexData, int vertexOffset, int primitiveCount)

Type Parameters:  

• T –

Parameters:

• primitiveType (Microsoft.Xna.Framework.Graphics.PrimitiveType) –
• vertexData (Microsoft.Xna.Framework.Graphics.T[]) –
• vertexOffset (int) –
• primitiveCount (int) –

public void DrawUserPrimitives<T>(PrimitiveType primitiveType, Microsoft.Xna.Framework.Graphics.T[] vertexData, int vertexOffset, int primitiveCount, VertexDeclaration vertexDeclaration)

Type Parameters:  

• T –

Parameters:

• primitiveType (Microsoft.Xna.Framework.Graphics.PrimitiveType) –
• vertexData (Microsoft.Xna.Framework.Graphics.T[]) –
• vertexOffset (int) –
• primitiveCount (int) –
• vertexDeclaration (Microsoft.Xna.Framework.Graphics.VertexDeclaration) –

public void DrawPrimitives(PrimitiveType primitiveType, int vertexStart, int primitiveCount)

Draw primitives of the specified type from the currently bound vertexbuffers without indexing.

Parameters:

• primitiveType (Microsoft.Xna.Framework.Graphics.PrimitiveType) – The type of primitives to draw.
• vertexStart (int) – Index of the vertex to start at.
• primitiveCount (int) – The number of primitives to draw.

public void DrawUserIndexedPrimitives<T>(PrimitiveType primitiveType, Microsoft.Xna.Framework.Graphics.T[] vertexData, int vertexOffset, int numVertices, System.Int16[] indexData, int indexOffset, int primitiveCount)

Type Parameters:  

• T –

Parameters:

• primitiveType (Microsoft.Xna.Framework.Graphics.PrimitiveType) –
• vertexData (Microsoft.Xna.Framework.Graphics.T[]) –
• vertexOffset (int) –
• numVertices (int) –
• indexData (System.Int16[]) –
• indexOffset (int) –
• primitiveCount (int) –

public void DrawUserIndexedPrimitives<T>(PrimitiveType primitiveType, Microsoft.Xna.Framework.Graphics.T[] vertexData, int vertexOffset, int numVertices, System.Int16[] indexData, int indexOffset, int primitiveCount, VertexDeclaration vertexDeclaration)

Type Parameters:  

• T –

Parameters:

• primitiveType (Microsoft.Xna.Framework.Graphics.PrimitiveType) –
• vertexData (Microsoft.Xna.Framework.Graphics.T[]) –
• vertexOffset (int) –
• numVertices (int) –
• indexData (System.Int16[]) –
• indexOffset (int) –
• primitiveCount (int) –
• vertexDeclaration (Microsoft.Xna.Framework.Graphics.VertexDeclaration) –

public void DrawUserIndexedPrimitives<T>(PrimitiveType primitiveType, Microsoft.Xna.Framework.Graphics.T[] vertexData, int vertexOffset, int numVertices, System.Int32[] indexData, int indexOffset, int primitiveCount)

Type Parameters:  

• T –

Parameters:

• primitiveType (Microsoft.Xna.Framework.Graphics.PrimitiveType) –
• vertexData (Microsoft.Xna.Framework.Graphics.T[]) –
• vertexOffset (int) –
• numVertices (int) –
• indexData (System.Int32[]) –
• indexOffset (int) –
• primitiveCount (int) –

public void DrawUserIndexedPrimitives<T>(PrimitiveType primitiveType, Microsoft.Xna.Framework.Graphics.T[] vertexData, int vertexOffset, int numVertices, System.Int32[] indexData, int indexOffset, int primitiveCount, VertexDeclaration vertexDeclaration)

Type Parameters:  

• T –

Parameters:

• primitiveType (Microsoft.Xna.Framework.Graphics.PrimitiveType) –
• vertexData (Microsoft.Xna.Framework.Graphics.T[]) –
• vertexOffset (int) –
• numVertices (int) –
• indexData (System.Int32[]) –
• indexOffset (int) –
• primitiveCount (int) –
• vertexDeclaration (Microsoft.Xna.Framework.Graphics.VertexDeclaration) –

public void DrawInstancedPrimitives(PrimitiveType primitiveType, int baseVertex, int minVertexIndex, int numVertices, int startIndex, int primitiveCount, int instanceCount)

Draw instanced geometry from the bound vertex buffers and index buffer.

Parameters:

• primitiveType (Microsoft.Xna.Framework.Graphics.PrimitiveType) – The type of primitives in the index buffer.
• baseVertex (int) – Used to offset the vertex range indexed from the vertex buffer.
• minVertexIndex (int) – This is unused and remains here only for XNA API compatibility.
• numVertices (int) – This is unused and remains here only for XNA API compatibility.
• startIndex (int) – The index within the index buffer to start drawing from.
• primitiveCount (int) – The number of primitives in a single instance.
• instanceCount (int) – The number of instances to render.

public void DrawInstancedPrimitives(PrimitiveType primitiveType, int baseVertex, int startIndex, int primitiveCount, int instanceCount)

Draw instanced geometry from the bound vertex buffers and index buffer.

Parameters:

• primitiveType (Microsoft.Xna.Framework.Graphics.PrimitiveType) – The type of primitives in the index buffer.
• baseVertex (int) – Used to offset the vertex range indexed from the vertex buffer.
• startIndex (int) – The index within the index buffer to start drawing from.
• primitiveCount (int) – The number of primitives in a single instance.
• instanceCount (int) – The number of instances to render.

GraphicsProfile GetHighestSupportedGraphicsProfile(GraphicsDevice graphicsDevice)

Parameters:

• graphicsDevice (Microsoft.Xna.Framework.Graphics.GraphicsDevice) –

Rectangle GetDefaultTitleSafeArea(int x, int y, int width, int height)

Parameters:

• x (int) –
• y (int) –
• width (int) –
• height (int) –

Rectangle GetTitleSafeArea(int x, int y, int width, int height)

Parameters:

• x (int) –
• y (int) –
• width (int) –
• height (int) –

void SetHardwareFullscreen()

void CreateSizeDependentResources()

void OnPresentationChanged()

public void SetRenderTarget(RenderTarget2D renderTarget, int arraySlice)

Parameters:

• renderTarget (Microsoft.Xna.Framework.Graphics.RenderTarget2D) –
• arraySlice (int) –

public void SetRenderTarget(RenderTarget3D renderTarget, int arraySlice)

Parameters:

• renderTarget (Microsoft.Xna.Framework.Graphics.RenderTarget3D) –
• arraySlice (int) –

void PlatformResolveRenderTargets()

GraphicsDeviceInformation

class GraphicsDeviceInformation : System.Object

The settings used in creation of the graphics device. See E:Microsoft.Xna.Framework.GraphicsDeviceManager.PreparingDeviceSettings.

GraphicsAdapter Adapter

The graphics adapter on which the graphics device will be created.

GraphicsProfile GraphicsProfile

The requested graphics device feature set.

PresentationParameters PresentationParameters

The settings that define how graphics will be presented to the display.

GraphicsDeviceManager

class GraphicsDeviceManager : System.Object, IGraphicsDeviceService, System.IDisposable, IGraphicsDeviceManager

Used to initialize and control the presentation of the graphics device.

int DefaultBackBufferWidth

The default back buffer width.

int DefaultBackBufferHeight

The default back buffer height.

GraphicsProfile GraphicsProfile

The profile which determines the graphics feature level.

readonly GraphicsDevice GraphicsDevice

Returns the graphics device for this manager.

bool IsFullScreen

Indicates the desire to switch into fullscreen mode.

bool HardwareModeSwitch

Gets or sets the boolean which defines how window switches from windowed to fullscreen state. “Hard” mode(true) is slow to switch, but more effecient for performance, while “soft” mode(false) is vice versa. The default value is true.

bool PreferMultiSampling

Indicates the desire for a multisampled back buffer.

SurfaceFormat PreferredBackBufferFormat

Indicates the desired back buffer color format.

int PreferredBackBufferHeight

Indicates the desired back buffer height in pixels.

int PreferredBackBufferWidth

Indicates the desired back buffer width in pixels.

DepthFormat PreferredDepthStencilFormat

Indicates the desired depth-stencil buffer format.

bool SynchronizeWithVerticalRetrace

Indicates the desire for vsync when presenting the back buffer.

DisplayOrientation SupportedOrientations

Indicates the desired allowable display orientations when the device is rotated.

public bool BeginDraw()

public void EndDraw()

public void add_DeviceCreated(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_DeviceCreated(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void add_DeviceDisposing(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_DeviceDisposing(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void add_DeviceReset(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_DeviceReset(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void add_DeviceResetting(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_DeviceResetting(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void add_PreparingDeviceSettings(System.EventHandler<PreparingDeviceSettingsEventArgs> value)

Parameters:

• value (System.EventHandler<PreparingDeviceSettingsEventArgs>) –

public void remove_PreparingDeviceSettings(System.EventHandler<PreparingDeviceSettingsEventArgs> value)

Parameters:

• value (System.EventHandler<PreparingDeviceSettingsEventArgs>) –

public void add_Disposed(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_Disposed(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

void OnDeviceReset(System.EventArgs e)

Parameters:

• e (System.EventArgs) –

void OnDeviceCreated(System.EventArgs e)

Parameters:

• e (System.EventArgs) –

public void Dispose()

public void ApplyChanges()

Applies any pending property changes to the graphics device.

public void ToggleFullScreen()

Toggles between windowed and fullscreen modes.

GraphicsDeviceStatus

enum GraphicsDeviceStatus : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Describes the status of the T:Microsoft.Xna.Framework.Graphics.GraphicsDevice.

GraphicsDeviceStatus Normal

The device is normal.

GraphicsDeviceStatus Lost

The device has been lost.

GraphicsDeviceStatus NotReset

The device has not been reset.

GraphicsMetrics

struct GraphicsMetrics : System.ValueType

A snapshot of rendering statistics from P:Microsoft.Xna.Framework.Graphics.GraphicsDevice.Metrics to be used for runtime debugging and profiling.

readonly long ClearCount

Number of times Clear was called.

readonly long DrawCount

Number of times Draw was called.

readonly long PixelShaderCount

Number of times the pixel shader was changed on the GPU.

readonly long PrimitiveCount

Number of rendered primitives.

readonly long SpriteCount

Number of sprites and text characters rendered via T:Microsoft.Xna.Framework.Graphics.SpriteBatch.

readonly long TargetCount

Number of times a target was changed on the GPU.

readonly long TextureCount

Number of times a texture was changed on the GPU.

readonly long VertexShaderCount

Number of times the vertex shader was changed on the GPU.

GraphicsMetrics op_Subtraction(GraphicsMetrics value1, GraphicsMetrics value2)

Returns the difference between two sets of metrics.

Parameters:

• value1 (Microsoft.Xna.Framework.Graphics.GraphicsMetrics) – Source T:Microsoft.Xna.Framework.Graphics.GraphicsMetrics on the left of the sub sign.
• value2 (Microsoft.Xna.Framework.Graphics.GraphicsMetrics) – Source T:Microsoft.Xna.Framework.Graphics.GraphicsMetrics on the right of the sub sign.

Returns:

Difference between two sets of metrics.

GraphicsMetrics op_Addition(GraphicsMetrics value1, GraphicsMetrics value2)

Returns the combination of two sets of metrics.

Parameters:

• value1 (Microsoft.Xna.Framework.Graphics.GraphicsMetrics) – Source T:Microsoft.Xna.Framework.Graphics.GraphicsMetrics on the left of the add sign.
• value2 (Microsoft.Xna.Framework.Graphics.GraphicsMetrics) – Source T:Microsoft.Xna.Framework.Graphics.GraphicsMetrics on the right of the add sign.

Returns:

Combination of two sets of metrics.

GraphicsProfile

enum GraphicsProfile : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines a set of graphic capabilities.

GraphicsProfile Reach

Use a limited set of graphic features and capabilities, allowing the game to support the widest variety of devices.

GraphicsProfile HiDef

Use the largest available set of graphic features and capabilities to target devices, that have more enhanced graphic capabilities.

GraphicsResource

class GraphicsResource : System.Object, System.IDisposable

readonly GraphicsDevice GraphicsDevice

readonly bool IsDisposed

string Name

System.Object Tag

void GraphicsDeviceResetting()

Called before the device is reset. Allows graphics resources to invalidate their state so they can be recreated after the device reset. Warning: This may be called after a call to Dispose() up until the resource is garbage collected.

public void Dispose()

public void add_Disposing(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_Disposing(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

void set_GraphicsDevice(GraphicsDevice value)

Parameters:

• value (Microsoft.Xna.Framework.Graphics.GraphicsDevice) –

public string ToString()

HalfSingle

struct HalfSingle : System.ValueType, Microsoft.Xna.Framework.Graphics.PackedVector.IPackedVector<UInt16>, IPackedVector, System.IEquatable<HalfSingle>

ushort PackedValue

float ToSingle()

bool Equals(System.Object obj)

Parameters:

• obj (System.Object) –

bool Equals(HalfSingle other)

Parameters:

• other (Microsoft.Xna.Framework.Graphics.PackedVector.HalfSingle) –

string ToString()

int GetHashCode()

bool op_Equality(HalfSingle lhs, HalfSingle rhs)

Parameters:

• lhs (Microsoft.Xna.Framework.Graphics.PackedVector.HalfSingle) –
• rhs (Microsoft.Xna.Framework.Graphics.PackedVector.HalfSingle) –

bool op_Inequality(HalfSingle lhs, HalfSingle rhs)

Parameters:

• lhs (Microsoft.Xna.Framework.Graphics.PackedVector.HalfSingle) –
• rhs (Microsoft.Xna.Framework.Graphics.PackedVector.HalfSingle) –

HalfVector2

struct HalfVector2 : System.ValueType, Microsoft.Xna.Framework.Graphics.PackedVector.IPackedVector<UInt32>, IPackedVector, System.IEquatable<HalfVector2>

uint PackedValue

Vector2 ToVector2()

string ToString()

int GetHashCode()

bool Equals(System.Object obj)

Parameters:

• obj (System.Object) –

bool Equals(HalfVector2 other)

Parameters:

• other (Microsoft.Xna.Framework.Graphics.PackedVector.HalfVector2) –

bool op_Equality(HalfVector2 a, HalfVector2 b)

Parameters:

• a (Microsoft.Xna.Framework.Graphics.PackedVector.HalfVector2) –
• b (Microsoft.Xna.Framework.Graphics.PackedVector.HalfVector2) –

bool op_Inequality(HalfVector2 a, HalfVector2 b)

Parameters:

• a (Microsoft.Xna.Framework.Graphics.PackedVector.HalfVector2) –
• b (Microsoft.Xna.Framework.Graphics.PackedVector.HalfVector2) –

HalfVector4

struct HalfVector4 : System.ValueType, Microsoft.Xna.Framework.Graphics.PackedVector.IPackedVector<UInt64>, IPackedVector, System.IEquatable<HalfVector4>

Packed vector type containing four 16-bit floating-point values.

ulong PackedValue

Directly gets or sets the packed representation of the value.

Value:The packed representation of the value.

Vector4 ToVector4()

Expands the packed representation into a Vector4.

Returns:The expanded vector.

string ToString()

Returns a string representation of the current instance.

Returns:String that represents the object.

int GetHashCode()

Gets the hash code for the current instance.

Returns:Hash code for the instance.

bool Equals(System.Object obj)

Returns a value that indicates whether the current instance is equal to a specified object.

Parameters:

• obj (System.Object) – The object with which to make the comparison.

Returns:

true if the current instance is equal to the specified object; false otherwise.

bool Equals(HalfVector4 other)

Returns a value that indicates whether the current instance is equal to a specified object.

Parameters:

• other (Microsoft.Xna.Framework.Graphics.PackedVector.HalfVector4) – The object with which to make the comparison.

Returns:

true if the current instance is equal to the specified object; false otherwise.

bool op_Equality(HalfVector4 a, HalfVector4 b)

Compares the current instance of a class to another instance to determine whether they are the same.

Parameters:

• a (Microsoft.Xna.Framework.Graphics.PackedVector.HalfVector4) – The object to the left of the equality operator.
• b (Microsoft.Xna.Framework.Graphics.PackedVector.HalfVector4) – The object to the right of the equality operator.

Returns:

true if the objects are the same; false otherwise.

bool op_Inequality(HalfVector4 a, HalfVector4 b)

Compares the current instance of a class to another instance to determine whether they are different.

Parameters:

• a (Microsoft.Xna.Framework.Graphics.PackedVector.HalfVector4) – The object to the left of the equality operator.
• b (Microsoft.Xna.Framework.Graphics.PackedVector.HalfVector4) – The object to the right of the equality operator.

Returns:

true if the objects are different; false otherwise.

IDrawable

interface IDrawable

readonly int DrawOrder

readonly bool Visible

void add_DrawOrderChanged(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

void remove_DrawOrderChanged(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

void add_VisibleChanged(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

void remove_VisibleChanged(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

void Draw(GameTime gameTime)

Parameters:

• gameTime (Microsoft.Xna.Framework.GameTime) –

IEffectFog

interface IEffectFog

The common effect fog rendering parameters.

Vector3 FogColor

The floating point fog color.

bool FogEnabled

Used to toggle the rendering of fog.

float FogEnd

The world space distance from the camera at which fogging is fully applied.

float FogStart

The world space distance from the camera at which fogging begins.

IEffectLights

interface IEffectLights

The common effect light rendering parameters.

Vector3 AmbientLightColor

The floating point ambient light color.

readonly DirectionalLight DirectionalLight0

Returns the first directional light.

readonly DirectionalLight DirectionalLight1

Returns the second directional light.

readonly DirectionalLight DirectionalLight2

Returns the third directional light.

bool LightingEnabled

Toggles the rendering of lighting.

void EnableDefaultLighting()

Initializes the lights to the standard key/fill/back lighting rig.

IEffectMatrices

interface IEffectMatrices

Matrix Projection

Matrix View

Matrix World

IEffectReader

interface IEffectReader

int GetEffectKey()

int GetConstantBufferCount()

string GetConstantBufferName(int constantBufferIndex)

Parameters:

• constantBufferIndex (int) –

int GetConstantBufferSize(int constantBufferIndex)

Parameters:

• constantBufferIndex (int) –

int GetConstantBufferParameterCount(int constantBufferIndex)

Parameters:

• constantBufferIndex (int) –

int GetConstantBufferParameterValue(int constantBufferIndex, int parameterIndex)

Parameters:

• constantBufferIndex (int) –
• parameterIndex (int) –

int GetConstantBufferParameterOffset(int constantBufferIndex, int parameterIndex)

Parameters:

• constantBufferIndex (int) –
• parameterIndex (int) –

int GetShaderCount()

IShaderReader GetShaderReader(int shaderIndex)

Parameters:

• shaderIndex (int) –

int GetParameterCount(System.Object parameterContext)

Parameters:

• parameterContext (System.Object) –

EffectParameterClass GetParameterClass(System.Object parameterContext, int parameterIndex)

Parameters:

• parameterContext (System.Object) –
• parameterIndex (int) –

EffectParameterType GetParameterType(System.Object parameterContext, int parameterIndex)

Parameters:

• parameterContext (System.Object) –
• parameterIndex (int) –

string GetParameterName(System.Object parameterContext, int parameterIndex)

Parameters:

• parameterContext (System.Object) –
• parameterIndex (int) –

string GetParameterSemantic(System.Object parameterContext, int parameterIndex)

Parameters:

• parameterContext (System.Object) –
• parameterIndex (int) –

int GetParameterAnnotationCount(System.Object parameterContext, int parameterIndex)

Parameters:

• parameterContext (System.Object) –
• parameterIndex (int) –

int GetParameterRowCount(System.Object parameterContext, int parameterIndex)

Parameters:

• parameterContext (System.Object) –
• parameterIndex (int) –

int GetParameterColumnCount(System.Object parameterContext, int parameterIndex)

Parameters:

• parameterContext (System.Object) –
• parameterIndex (int) –

int GetParameterInt32Buffer(System.Object parameterContext, int parameterIndex, int bufferIndex)

Parameters:

• parameterContext (System.Object) –
• parameterIndex (int) –
• bufferIndex (int) –

float GetParameterFloatBuffer(System.Object parameterContext, int parameterIndex, int bufferIndex)

Parameters:

• parameterContext (System.Object) –
• parameterIndex (int) –
• bufferIndex (int) –

System.Object GetParameterElementsContext(System.Object parameterContext, int parameterIndex)

Parameters:

• parameterContext (System.Object) –
• parameterIndex (int) –

System.Object GetParameterStructMembersContext(System.Object parameterContext, int parameterIndex)

Parameters:

• parameterContext (System.Object) –
• parameterIndex (int) –

int GetTechniqueCount()

string GetTechniqueName(int techniqueIndex)

Parameters:

• techniqueIndex (int) –

int GetTechniqueAnnotationCount(int techniqueIndex)

Parameters:

• techniqueIndex (int) –

int GetPassCount(int techniqueIndex)

Parameters:

• techniqueIndex (int) –

string GetPassName(int techniqueIndex, int passIndex)

Parameters:

• techniqueIndex (int) –
• passIndex (int) –

int GetPassAnnotationCount(int techniqueIndex, int passIndex)

Parameters:

• techniqueIndex (int) –
• passIndex (int) –

System.Nullable<Int32> GetPassVertexShaderIndex(int techniqueIndex, int passIndex)

Parameters:

• techniqueIndex (int) –
• passIndex (int) –

System.Nullable<Int32> GetPassPixelShaderIndex(int techniqueIndex, int passIndex)

Parameters:

• techniqueIndex (int) –
• passIndex (int) –

BlendState GetPassBlendState(int techniqueIndex, int passIndex)

Parameters:

• techniqueIndex (int) –
• passIndex (int) –

DepthStencilState GetPassDepthStencilState(int techniqueIndex, int passIndex)

Parameters:

• techniqueIndex (int) –
• passIndex (int) –

RasterizerState GetPassRasterizerState(int techniqueIndex, int passIndex)

Parameters:

• techniqueIndex (int) –
• passIndex (int) –

IGameComponent

interface IGameComponent

void Initialize()

IGraphicsContext

interface IGraphicsContext : System.IDisposable

int SwapInterval

readonly bool IsDisposed

void MakeCurrent(IWindowInfo info)

Parameters:

• info (OpenGL.IWindowInfo) –

void SwapBuffers()

IGraphicsDeviceManager

interface IGraphicsDeviceManager

Used by the platform code to control the graphics device.

bool BeginDraw()

Called at the start of rendering a frame.

Returns:Returns true if the frame should be rendered.

void CreateDevice()

Called to create the graphics device.

void EndDraw()

Called after rendering to present the frame to the screen.

IGraphicsDeviceService

interface IGraphicsDeviceService

readonly GraphicsDevice GraphicsDevice

void add_DeviceCreated(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

void remove_DeviceCreated(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

void add_DeviceDisposing(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

void remove_DeviceDisposing(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

void add_DeviceReset(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

void remove_DeviceReset(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

void add_DeviceResetting(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

void remove_DeviceResetting(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

IndexBuffer

class IndexBuffer : GraphicsResource, System.IDisposable

readonly BufferUsage BufferUsage

readonly int IndexCount

readonly IndexElementSize IndexElementSize

void GraphicsDeviceResetting()

The GraphicsDevice is resetting, so GPU resources must be recreated.

public void GetData<T>(int offsetInBytes, Microsoft.Xna.Framework.Graphics.T[] data, int startIndex, int elementCount)

Type Parameters:  

• T –

Parameters:

• offsetInBytes (int) –
• data (Microsoft.Xna.Framework.Graphics.T[]) –
• startIndex (int) –
• elementCount (int) –

public void GetData<T>(Microsoft.Xna.Framework.Graphics.T[] data, int startIndex, int elementCount)

Type Parameters:  

• T –

Parameters:

• data (Microsoft.Xna.Framework.Graphics.T[]) –
• startIndex (int) –
• elementCount (int) –

public void GetData<T>(Microsoft.Xna.Framework.Graphics.T[] data)

Type Parameters:  

• T –

Parameters:

• data (Microsoft.Xna.Framework.Graphics.T[]) –

public void SetData<T>(int offsetInBytes, Microsoft.Xna.Framework.Graphics.T[] data, int startIndex, int elementCount)

Type Parameters:  

• T –

Parameters:

• offsetInBytes (int) –
• data (Microsoft.Xna.Framework.Graphics.T[]) –
• startIndex (int) –
• elementCount (int) –

public void SetData<T>(Microsoft.Xna.Framework.Graphics.T[] data, int startIndex, int elementCount)

Type Parameters:  

• T –

Parameters:

• data (Microsoft.Xna.Framework.Graphics.T[]) –
• startIndex (int) –
• elementCount (int) –

public void SetData<T>(Microsoft.Xna.Framework.Graphics.T[] data)

Type Parameters:  

• T –

Parameters:

• data (Microsoft.Xna.Framework.Graphics.T[]) –

SharpDX.Direct3D11.Buffer get_Buffer()

IndexElementSize

enum IndexElementSize : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines size for index in T:Microsoft.Xna.Framework.Graphics.IndexBuffer and T:Microsoft.Xna.Framework.Graphics.DynamicIndexBuffer.

IndexElementSize SixteenBits

16-bit short/ushort value been used.

IndexElementSize ThirtyTwoBits

32-bit int/uint value been used.

InstancePlayLimitException

class InstancePlayLimitException : System.Runtime.InteropServices.ExternalException, System.Runtime.Serialization.ISerializable, System.Runtime.InteropServices._Exception

The exception thrown when the system attempts to play more SoundEffectInstances than allotted.

IPackedVector

interface IPackedVector

void PackFromVector4(Vector4 vector)

Parameters:

• vector (Microsoft.Xna.Framework.Vector4) –

Vector4 ToVector4()

IPackedVector<TPacked>

interface IPackedVector<TPacked> : IPackedVector

Type Parameters:  

• TPacked –

Microsoft.Xna.Framework.Graphics.PackedVector.TPacked PackedValue

IShaderReader

interface IShaderReader

ShaderStage GetStage()

System.Byte[] GetBytecode()

int GetSamplerCount()

SamplerType GetSamplerType(int samplerIndex)

Parameters:

• samplerIndex (int) –

int GetSamplerTextureSlot(int samplerIndex)

Parameters:

• samplerIndex (int) –

int GetSamplerSamplerSlot(int samplerIndex)

Parameters:

• samplerIndex (int) –

SamplerState GetSamplerState(int samplerIndex)

Parameters:

• samplerIndex (int) –

string GetSamplerName(int samplerIndex)

Parameters:

• samplerIndex (int) –

int GetSamplerParameter(int samplerIndex)

Parameters:

• samplerIndex (int) –

int GetConstantBufferCount()

int GetConstantBufferValue(int constantBufferIndex)

Parameters:

• constantBufferIndex (int) –

int GetAttributeCount()

string GetAttributeName(int attributeIndex)

Parameters:

• attributeIndex (int) –

VertexElementUsage GetAttributeUsage(int attributeIndex)

Parameters:

• attributeIndex (int) –

int GetAttributeIndexInShader(int attributeIndex)

Parameters:

• attributeIndex (int) –

int GetAttributeLocation(int attributeIndex)

Parameters:

• attributeIndex (int) –

IUpdateable

interface IUpdateable

readonly bool Enabled

readonly int UpdateOrder

void Update(GameTime gameTime)

Parameters:

• gameTime (Microsoft.Xna.Framework.GameTime) –

void add_EnabledChanged(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

void remove_EnabledChanged(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

void add_UpdateOrderChanged(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

void remove_UpdateOrderChanged(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

IVertexType

interface IVertexType

readonly VertexDeclaration VertexDeclaration

IWindowInfo

interface IWindowInfo

readonly System.IntPtr Handle

Joystick

class Joystick : System.Object

Allows interaction with joysticks. Unlike T:Microsoft.Xna.Framework.Input.GamePad the number of Buttons/Axes/DPads is not limited.

public JoystickCapabilities GetCapabilities(int index)

Gets the capabilites of the joystick.

Parameters:

• index (int) – Index of the joystick you want to access.

Returns:

The capabilites of the joystick.

public JoystickState GetState(int index)

Gets the current state of the joystick.

Parameters:

• index (int) – Index of the joystick you want to access.

Returns:

The state of the joystick.

JoystickCapabilities

struct JoystickCapabilities : System.ValueType

Describes joystick capabilities.

readonly bool IsConnected

Gets a value indicating whether the joystick is connected.

Value:true if the joystick is connected; otherwise, false.

readonly string Id

Gets the unique identifier of the joystick.

Value:String representing the unique identifier of the joystick.

readonly int AxisCount

Gets the axis count.

Value:The number of axes that the joystick possesses.

readonly int ButtonCount

Gets the button count.

Value:The number of buttons that the joystick possesses.

readonly int HatCount

Gets the hat count.

Value:The number of hats/dpads that the joystick possesses.

void set_IsConnected(bool value)

Parameters:

• value (bool) –

void set_Id(string value)

Parameters:

• value (string) –

void set_AxisCount(int value)

Parameters:

• value (int) –

void set_ButtonCount(int value)

Parameters:

• value (int) –

void set_HatCount(int value)

Parameters:

• value (int) –

JoystickHat

struct JoystickHat : System.ValueType

Describes joystick hat state.

readonly ButtonState Down

Gets if joysticks hat “down” is pressed.

Value:F:Microsoft.Xna.Framework.Input.ButtonState.Pressed if the button is pressed otherwise, F:Microsoft.Xna.Framework.Input.ButtonState.Released.

readonly ButtonState Left

Gets if joysticks hat “left” is pressed.

Value:F:Microsoft.Xna.Framework.Input.ButtonState.Pressed if the button is pressed otherwise, F:Microsoft.Xna.Framework.Input.ButtonState.Released.

readonly ButtonState Right

Gets if joysticks hat “right” is pressed.

Value:F:Microsoft.Xna.Framework.Input.ButtonState.Pressed if the button is pressed otherwise, F:Microsoft.Xna.Framework.Input.ButtonState.Released.

readonly ButtonState Up

Gets if joysticks hat “up” is pressed.

Value:F:Microsoft.Xna.Framework.Input.ButtonState.Pressed if the button is pressed otherwise, F:Microsoft.Xna.Framework.Input.ButtonState.Released.

void set_Down(ButtonState value)

Parameters:

• value (Microsoft.Xna.Framework.Input.ButtonState) –

void set_Left(ButtonState value)

Parameters:

• value (Microsoft.Xna.Framework.Input.ButtonState) –

void set_Right(ButtonState value)

Parameters:

• value (Microsoft.Xna.Framework.Input.ButtonState) –

void set_Up(ButtonState value)

Parameters:

• value (Microsoft.Xna.Framework.Input.ButtonState) –

JoystickState

struct JoystickState : System.ValueType

Describes current joystick state.

readonly bool IsConnected

Gets a value indicating whether the joystick is connected.

Value:true if the joystick is connected; otherwise, false.

readonly System.Single[] Axes

Gets the joystick axis values.

Value:An array list of floats that indicate axis values.

readonly Microsoft.Xna.Framework.Input.ButtonState[] Buttons

Gets the joystick button values.

Value:An array list of ButtonState that indicate button values.

readonly Microsoft.Xna.Framework.Input.JoystickHat[] Hats

Gets the joystick hat values.

Value:An array list of T:Microsoft.Xna.Framework.Input.JoystickHat that indicate hat values.

void set_IsConnected(bool value)

Parameters:

• value (bool) –

void set_Axes(System.Single[] value)

Parameters:

• value (System.Single[]) –

void set_Buttons(Microsoft.Xna.Framework.Input.ButtonState[] value)

Parameters:

• value (Microsoft.Xna.Framework.Input.ButtonState[]) –

void set_Hats(Microsoft.Xna.Framework.Input.JoystickHat[] value)

Parameters:

• value (Microsoft.Xna.Framework.Input.JoystickHat[]) –

Keyboard

class Keyboard : System.Object

Allows getting keystrokes from keyboard.

public KeyboardState GetState()

Returns the current keyboard state.

Returns:Current keyboard state.

public KeyboardState GetState(PlayerIndex playerIndex)

Returns the current keyboard state for a given player.

Parameters:

• playerIndex (Microsoft.Xna.Framework.PlayerIndex) – Player index of the keyboard.

Returns:

Current keyboard state.

void SetActive(bool isActive)

Parameters:

• isActive (bool) –

KeyboardState

struct KeyboardState : System.ValueType

Holds the state of keystrokes by a keyboard.

readonly bool CapsLock

Gets the current state of the Caps Lock key.

readonly bool NumLock

Gets the current state of the Num Lock key.

readonly KeyState Item

bool IsKeyDown(Keys key)

Gets whether given key is currently being pressed.

Parameters:

• key (Microsoft.Xna.Framework.Input.Keys) – The key to query.

Returns:

true if the key is pressed; false otherwise.

bool IsKeyUp(Keys key)

Gets whether given key is currently being not pressed.

Parameters:

• key (Microsoft.Xna.Framework.Input.Keys) – The key to query.

Returns:

true if the key is not pressed; false otherwise.

Microsoft.Xna.Framework.Input.Keys[] GetPressedKeys()

Returns an array of values holding keys that are currently being pressed.

Returns:The keys that are currently being pressed.

int GetHashCode()

Gets the hash code for T:Microsoft.Xna.Framework.Input.KeyboardState instance.

Returns:Hash code of the object.

bool op_Equality(KeyboardState a, KeyboardState b)

Compares whether two T:Microsoft.Xna.Framework.Input.KeyboardState instances are equal.

Parameters:

• a (Microsoft.Xna.Framework.Input.KeyboardState) – T:Microsoft.Xna.Framework.Input.KeyboardState instance to the left of the equality operator.
• b (Microsoft.Xna.Framework.Input.KeyboardState) – T:Microsoft.Xna.Framework.Input.KeyboardState instance to the right of the equality operator.

Returns:

true if the instances are equal; false otherwise.

bool op_Inequality(KeyboardState a, KeyboardState b)

Compares whether two T:Microsoft.Xna.Framework.Input.KeyboardState instances are not equal.

Parameters:

• a (Microsoft.Xna.Framework.Input.KeyboardState) – T:Microsoft.Xna.Framework.Input.KeyboardState instance to the left of the inequality operator.
• b (Microsoft.Xna.Framework.Input.KeyboardState) – T:Microsoft.Xna.Framework.Input.KeyboardState instance to the right of the inequality operator.

Returns:

true if the instances are different; false otherwise.

bool Equals(System.Object obj)

Compares whether current instance is equal to specified object.

Parameters:

• obj (System.Object) – The T:Microsoft.Xna.Framework.Input.KeyboardState to compare.

Returns:

true if the provided T:Microsoft.Xna.Framework.Input.KeyboardState instance is same with current; false otherwise.

Keys

enum Keys : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines the keys on a keyboard.

Keys None

Reserved.

Keys Back

BACKSPACE key.

Keys Tab

TAB key.

Keys Enter

ENTER key.

Keys CapsLock

CAPS LOCK key.

Keys Escape

ESC key.

Keys Space

SPACEBAR key.

Keys PageUp

PAGE UP key.

Keys PageDown

PAGE DOWN key.

Keys End

END key.

Keys Home

HOME key.

Keys Left

LEFT ARROW key.

Keys Up

UP ARROW key.

Keys Right

RIGHT ARROW key.

Keys Down

DOWN ARROW key.

Keys Select

SELECT key.

Keys Print

PRINT key.

Keys Execute

EXECUTE key.

Keys PrintScreen

PRINT SCREEN key.

Keys Insert

INS key.

Keys Delete

DEL key.

Keys Help

HELP key.

Keys D0

Used for miscellaneous characters; it can vary by keyboard.

Keys D1

Used for miscellaneous characters; it can vary by keyboard.

Keys D2

Used for miscellaneous characters; it can vary by keyboard.

Keys D3

Used for miscellaneous characters; it can vary by keyboard.

Keys D4

Used for miscellaneous characters; it can vary by keyboard.

Keys D5

Used for miscellaneous characters; it can vary by keyboard.

Keys D6

Used for miscellaneous characters; it can vary by keyboard.

Keys D7

Used for miscellaneous characters; it can vary by keyboard.

Keys D8

Used for miscellaneous characters; it can vary by keyboard.

Keys D9

Used for miscellaneous characters; it can vary by keyboard.

Keys A

A key.

Keys B

B key.

Keys C

C key.

Keys D

D key.

Keys E

E key.

Keys F

F key.

Keys G

G key.

Keys H

H key.

Keys I

I key.

Keys J

J key.

Keys K

K key.

Keys L

L key.

Keys M

M key.

Keys N

N key.

Keys O

O key.

Keys P

P key.

Keys Q

Q key.

Keys R

R key.

Keys S

S key.

Keys T

T key.

Keys U

U key.

Keys V

V key.

Keys W

W key.

Keys X

X key.

Keys Y

Y key.

Keys Z

Z key.

Keys LeftWindows

Left Windows key.

Keys RightWindows

Right Windows key.

Keys Apps

Applications key.

Keys Sleep

Computer Sleep key.

Keys NumPad0

Numeric keypad 0 key.

Keys NumPad1

Numeric keypad 1 key.

Keys NumPad2

Numeric keypad 2 key.

Keys NumPad3

Numeric keypad 3 key.

Keys NumPad4

Numeric keypad 4 key.

Keys NumPad5

Numeric keypad 5 key.

Keys NumPad6

Numeric keypad 6 key.

Keys NumPad7

Numeric keypad 7 key.

Keys NumPad8

Numeric keypad 8 key.

Keys NumPad9

Numeric keypad 9 key.

Keys Multiply

Multiply key.

Keys Add

Add key.

Keys Separator

Separator key.

Keys Subtract

Subtract key.

Keys Decimal

Decimal key.

Keys Divide

Divide key.

Keys F1

F1 key.

Keys F2

F2 key.

Keys F3

F3 key.

Keys F4

F4 key.

Keys F5

F5 key.

Keys F6

F6 key.

Keys F7

F7 key.

Keys F8

F8 key.

Keys F9

F9 key.

Keys F10

F10 key.

Keys F11

F11 key.

Keys F12

F12 key.

Keys F13

F13 key.

Keys F14

F14 key.

Keys F15

F15 key.

Keys F16

F16 key.

Keys F17

F17 key.

Keys F18

F18 key.

Keys F19

F19 key.

Keys F20

F20 key.

Keys F21

F21 key.

Keys F22

F22 key.

Keys F23

F23 key.

Keys F24

F24 key.

Keys NumLock

NUM LOCK key.

Keys Scroll

SCROLL LOCK key.

Keys LeftShift

Left SHIFT key.

Keys RightShift

Right SHIFT key.

Keys LeftControl

Left CONTROL key.

Keys RightControl

Right CONTROL key.

Keys LeftAlt

Left ALT key.

Keys RightAlt

Right ALT key.

Keys BrowserBack

Browser Back key.

Keys BrowserForward

Browser Forward key.

Keys BrowserRefresh

Browser Refresh key.

Keys BrowserStop

Browser Stop key.

Keys BrowserSearch

Browser Search key.

Keys BrowserFavorites

Browser Favorites key.

Keys BrowserHome

Browser Start and Home key.

Keys VolumeMute

Volume Mute key.

Keys VolumeDown

Volume Down key.

Keys VolumeUp

Volume Up key.

Keys MediaNextTrack

Next Track key.

Keys MediaPreviousTrack

Previous Track key.

Keys MediaStop

Stop Media key.

Keys MediaPlayPause

Play/Pause Media key.

Keys LaunchMail

Start Mail key.

Keys SelectMedia

Select Media key.

Keys LaunchApplication1

Start Application 1 key.

Keys LaunchApplication2

Start Application 2 key.

Keys OemSemicolon

The OEM Semicolon key on a US standard keyboard.

Keys OemPlus

For any country/region, the ‘+’ key.

Keys OemComma

For any country/region, the ‘,’ key.

Keys OemMinus

For any country/region, the ‘-‘ key.

Keys OemPeriod

For any country/region, the ‘.’ key.

Keys OemQuestion

The OEM question mark key on a US standard keyboard.

Keys OemTilde

The OEM tilde key on a US standard keyboard.

Keys OemOpenBrackets

The OEM open bracket key on a US standard keyboard.

Keys OemPipe

The OEM pipe key on a US standard keyboard.

Keys OemCloseBrackets

The OEM close bracket key on a US standard keyboard.

Keys OemQuotes

The OEM singled/double quote key on a US standard keyboard.

Keys Oem8

Used for miscellaneous characters; it can vary by keyboard.

Keys OemBackslash

The OEM angle bracket or backslash key on the RT 102 key keyboard.

Keys ProcessKey

IME PROCESS key.

Keys Attn

Attn key.

Keys Crsel

CrSel key.

Keys Exsel

ExSel key.

Keys EraseEof

Erase EOF key.

Keys Play

Play key.

Keys Zoom

Zoom key.

Keys Pa1

PA1 key.

Keys OemClear

CLEAR key.

Keys ChatPadGreen

Green ChatPad key.

Keys ChatPadOrange

Orange ChatPad key.

Keys Pause

PAUSE key.

Keys ImeConvert

IME Convert key.

Keys ImeNoConvert

IME NoConvert key.

Keys Kana

Kana key on Japanese keyboards.

Keys Kanji

Kanji key on Japanese keyboards.

Keys OemAuto

OEM Auto key.

Keys OemCopy

OEM Copy key.

Keys OemEnlW

OEM Enlarge Window key.

KeyState

enum KeyState : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Identifies the state of a keyboard key.

KeyState Up

Key is released.

KeyState Down

Key is pressed.

LaunchParameters

class LaunchParameters : System.Collections.Generic.Dictionary<String, String>, System.Collections.Generic.IDictionary<String, String>, System.Collections.Generic.ICollection<KeyValuePair`2>, System.Collections.Generic.IEnumerable<KeyValuePair`2>, System.Collections.IEnumerable, System.Collections.IDictionary, System.Collections.ICollection, System.Collections.Generic.IReadOnlyDictionary<String, String>, System.Collections.Generic.IReadOnlyCollection<KeyValuePair`2>, System.Runtime.Serialization.ISerializable, System.Runtime.Serialization.IDeserializationCallback

MathHelper

class MathHelper : System.Object

Contains commonly used precalculated values and mathematical operations.

float E

Represents the mathematical constant e(2.71828175).

float Log10E

Represents the log base ten of e(0.4342945).

float Log2E

Represents the log base two of e(1.442695).

float Pi

Represents the value of pi(3.14159274).

float PiOver2

Represents the value of pi divided by two(1.57079637).

float PiOver4

Represents the value of pi divided by four(0.7853982).

float TwoPi

Represents the value of pi times two(6.28318548).

public float Barycentric(float value1, float value2, float value3, float amount1, float amount2)

Returns the Cartesian coordinate for one axis of a point that is defined by a given triangle and two normalized barycentric (areal) coordinates.

Parameters:

• value1 (float) – The coordinate on one axis of vertex 1 of the defining triangle.
• value2 (float) – The coordinate on the same axis of vertex 2 of the defining triangle.
• value3 (float) – The coordinate on the same axis of vertex 3 of the defining triangle.
• amount1 (float) – The normalized barycentric (areal) coordinate b2, equal to the weighting factor for vertex 2, the coordinate of which is specified in value2.
• amount2 (float) – The normalized barycentric (areal) coordinate b3, equal to the weighting factor for vertex 3, the coordinate of which is specified in value3.

Returns:

Cartesian coordinate of the specified point with respect to the axis being used.

public float CatmullRom(float value1, float value2, float value3, float value4, float amount)

Performs a Catmull-Rom interpolation using the specified positions.

Parameters:

• value1 (float) – The first position in the interpolation.
• value2 (float) – The second position in the interpolation.
• value3 (float) – The third position in the interpolation.
• value4 (float) – The fourth position in the interpolation.
• amount (float) – Weighting factor.

Returns:

A position that is the result of the Catmull-Rom interpolation.

public float Clamp(float value, float min, float max)

Restricts a value to be within a specified range.

Parameters:

• value (float) – The value to clamp.
• min (float) – The minimum value. If value is less than min, min will be returned.
• max (float) – The maximum value. If value is greater than max, max will be returned.

Returns:

The clamped value.

public int Clamp(int value, int min, int max)

Restricts a value to be within a specified range.

Parameters:

• value (int) – The value to clamp.
• min (int) – The minimum value. If value is less than min, min will be returned.
• max (int) – The maximum value. If value is greater than max, max will be returned.

Returns:

The clamped value.

public float Distance(float value1, float value2)

Calculates the absolute value of the difference of two values.

Parameters:

• value1 (float) – Source value.
• value2 (float) – Source value.

Returns:

Distance between the two values.

public float Hermite(float value1, float tangent1, float value2, float tangent2, float amount)

Performs a Hermite spline interpolation.

Parameters:

• value1 (float) – Source position.
• tangent1 (float) – Source tangent.
• value2 (float) – Source position.
• tangent2 (float) – Source tangent.
• amount (float) – Weighting factor.

Returns:

The result of the Hermite spline interpolation.

public float Lerp(float value1, float value2, float amount)

Linearly interpolates between two values.

Parameters:

• value1 (float) – Source value.
• value2 (float) – Destination value.
• amount (float) – Value between 0 and 1 indicating the weight of value2.

Returns:

Interpolated value.

public float LerpPrecise(float value1, float value2, float amount)

Linearly interpolates between two values. This method is a less efficient, more precise version of M:Microsoft.Xna.Framework.MathHelper.Lerp(System.Single,System.Single,System.Single). See remarks for more info.

Parameters:

• value1 (float) – Source value.
• value2 (float) – Destination value.
• amount (float) – Value between 0 and 1 indicating the weight of value2.

Returns:

Interpolated value.

public float Max(float value1, float value2)

Returns the greater of two values.

Parameters:

• value1 (float) – Source value.
• value2 (float) – Source value.

Returns:

The greater value.

public int Max(int value1, int value2)

Returns the greater of two values.

Parameters:

• value1 (int) – Source value.
• value2 (int) – Source value.

Returns:

The greater value.

public float Min(float value1, float value2)

Returns the lesser of two values.

Parameters:

• value1 (float) – Source value.
• value2 (float) – Source value.

Returns:

The lesser value.

public int Min(int value1, int value2)

Returns the lesser of two values.

Parameters:

• value1 (int) – Source value.
• value2 (int) – Source value.

Returns:

The lesser value.

public float SmoothStep(float value1, float value2, float amount)

Interpolates between two values using a cubic equation.

Parameters:

• value1 (float) – Source value.
• value2 (float) – Source value.
• amount (float) – Weighting value.

Returns:

Interpolated value.

public float ToDegrees(float radians)

Converts radians to degrees.

Parameters:

• radians (float) – The angle in radians.

Returns:

The angle in degrees.

public float ToRadians(float degrees)

Converts degrees to radians.

Parameters:

• degrees (float) – The angle in degrees.

Returns:

The angle in radians.

public float WrapAngle(float angle)

Reduces a given angle to a value between π and -π.

Parameters:

• angle (float) – The angle to reduce, in radians.

Returns:

The new angle, in radians.

public bool IsPowerOfTwo(int value)

Determines if value is powered by two.

Parameters:

• value (int) – A value.

Returns:

true if value is powered by two; otherwise false.

Matrix

struct Matrix : System.ValueType, System.IEquatable<Matrix>

Represents the right-handed 4x4 floating point matrix, which can store translation, scale and rotation information.

float M11

A first row and first column value.

float M12

A first row and second column value.

float M13

A first row and third column value.

float M14

A first row and fourth column value.

float M21

A second row and first column value.

float M22

A second row and second column value.

float M23

A second row and third column value.

float M24

A second row and fourth column value.

float M31

A third row and first column value.

float M32

A third row and second column value.

float M33

A third row and third column value.

float M34

A third row and fourth column value.

float M41

A fourth row and first column value.

float M42

A fourth row and second column value.

float M43

A fourth row and third column value.

float M44

A fourth row and fourth column value.

float Item

float Item

Vector3 Backward

The backward vector formed from the third row M31, M32, M33 elements.

Vector3 Down

The down vector formed from the second row -M21, -M22, -M23 elements.

Vector3 Forward

The forward vector formed from the third row -M31, -M32, -M33 elements.

readonly Matrix Identity

Returns the identity matrix.

Vector3 Left

The left vector formed from the first row -M11, -M12, -M13 elements.

Vector3 Right

The right vector formed from the first row M11, M12, M13 elements.

readonly Quaternion Rotation

Rotation stored in this matrix.

Vector3 Translation

Position stored in this matrix.

Vector3 Scale

Scale stored in this matrix.

Vector3 Up

The upper vector formed from the second row M21, M22, M23 elements.

Matrix Add(Matrix matrix1, Matrix matrix2)

Creates a new T:Microsoft.Xna.Framework.Matrix which contains sum of two matrixes.

Parameters:

• matrix1 (Microsoft.Xna.Framework.Matrix) – The first matrix to add.
• matrix2 (Microsoft.Xna.Framework.Matrix) – The second matrix to add.

Returns:

The result of the matrix addition.

void Add(ref Matrix matrix1, ref Matrix matrix2, ref Matrix result)

Parameters:

• (ref) matrix1 (Microsoft.Xna.Framework.Matrix) –
• (ref) matrix2 (Microsoft.Xna.Framework.Matrix) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

Matrix CreateBillboard(Vector3 objectPosition, Vector3 cameraPosition, Vector3 cameraUpVector, System.Nullable<Vector3> cameraForwardVector)

Creates a new T:Microsoft.Xna.Framework.Matrix for spherical billboarding that rotates around specified object position.

Parameters:

• objectPosition (Microsoft.Xna.Framework.Vector3) – Position of billboard object. It will rotate around that vector.
• cameraPosition (Microsoft.Xna.Framework.Vector3) – The camera position.
• cameraUpVector (Microsoft.Xna.Framework.Vector3) – The camera up vector.
• cameraForwardVector (System.Nullable<Vector3>) – Optional camera forward vector.

Returns:

The T:Microsoft.Xna.Framework.Matrix for spherical billboarding.

void CreateBillboard(ref Vector3 objectPosition, ref Vector3 cameraPosition, ref Vector3 cameraUpVector, System.Nullable<Vector3> cameraForwardVector, ref Matrix result)

Parameters:

• (ref) objectPosition (Microsoft.Xna.Framework.Vector3) –
• (ref) cameraPosition (Microsoft.Xna.Framework.Vector3) –
• (ref) cameraUpVector (Microsoft.Xna.Framework.Vector3) –
• cameraForwardVector (System.Nullable<Vector3>) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

Matrix CreateConstrainedBillboard(Vector3 objectPosition, Vector3 cameraPosition, Vector3 rotateAxis, System.Nullable<Vector3> cameraForwardVector, System.Nullable<Vector3> objectForwardVector)

Creates a new T:Microsoft.Xna.Framework.Matrix for cylindrical billboarding that rotates around specified axis.

Parameters:

• objectPosition (Microsoft.Xna.Framework.Vector3) – Object position the billboard will rotate around.
• cameraPosition (Microsoft.Xna.Framework.Vector3) – Camera position.
• rotateAxis (Microsoft.Xna.Framework.Vector3) – Axis of billboard for rotation.
• cameraForwardVector (System.Nullable<Vector3>) – Optional camera forward vector.
• objectForwardVector (System.Nullable<Vector3>) – Optional object forward vector.

Returns:

The T:Microsoft.Xna.Framework.Matrix for cylindrical billboarding.

void CreateConstrainedBillboard(ref Vector3 objectPosition, ref Vector3 cameraPosition, ref Vector3 rotateAxis, System.Nullable<Vector3> cameraForwardVector, System.Nullable<Vector3> objectForwardVector, ref Matrix result)

Parameters:

• (ref) objectPosition (Microsoft.Xna.Framework.Vector3) –
• (ref) cameraPosition (Microsoft.Xna.Framework.Vector3) –
• (ref) rotateAxis (Microsoft.Xna.Framework.Vector3) –
• cameraForwardVector (System.Nullable<Vector3>) –
• objectForwardVector (System.Nullable<Vector3>) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

Matrix CreateFromAxisAngle(Vector3 axis, float angle)

Creates a new T:Microsoft.Xna.Framework.Matrix which contains the rotation moment around specified axis.

Parameters:

• axis (Microsoft.Xna.Framework.Vector3) – The axis of rotation.
• angle (float) – The angle of rotation in radians.

Returns:

The rotation T:Microsoft.Xna.Framework.Matrix.

void CreateFromAxisAngle(ref Vector3 axis, float angle, ref Matrix result)

Parameters:

• (ref) axis (Microsoft.Xna.Framework.Vector3) –
• angle (float) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

Matrix CreateFromQuaternion(Quaternion quaternion)

Creates a new rotation T:Microsoft.Xna.Framework.Matrix from a T:Microsoft.Xna.Framework.Quaternion.

Parameters:

• quaternion (Microsoft.Xna.Framework.Quaternion) – T:Microsoft.Xna.Framework.Quaternion of rotation moment.

Returns:

The rotation T:Microsoft.Xna.Framework.Matrix.

void CreateFromQuaternion(ref Quaternion quaternion, ref Matrix result)

Parameters:

• (ref) quaternion (Microsoft.Xna.Framework.Quaternion) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

Matrix CreateFromYawPitchRoll(float yaw, float pitch, float roll)

Creates a new rotation T:Microsoft.Xna.Framework.Matrix from the specified yaw, pitch and roll values.

Parameters:

• yaw (float) – The yaw rotation value in radians.
• pitch (float) – The pitch rotation value in radians.
• roll (float) – The roll rotation value in radians.

Returns:

The rotation T:Microsoft.Xna.Framework.Matrix.

void CreateFromYawPitchRoll(float yaw, float pitch, float roll, ref Matrix result)

Parameters:

• yaw (float) –
• pitch (float) –
• roll (float) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

Matrix CreateLookAt(Vector3 cameraPosition, Vector3 cameraTarget, Vector3 cameraUpVector)

Creates a new viewing T:Microsoft.Xna.Framework.Matrix.

Parameters:

• cameraPosition (Microsoft.Xna.Framework.Vector3) – Position of the camera.
• cameraTarget (Microsoft.Xna.Framework.Vector3) – Lookup vector of the camera.
• cameraUpVector (Microsoft.Xna.Framework.Vector3) – The direction of the upper edge of the camera.

Returns:

The viewing T:Microsoft.Xna.Framework.Matrix.

void CreateLookAt(ref Vector3 cameraPosition, ref Vector3 cameraTarget, ref Vector3 cameraUpVector, ref Matrix result)

Parameters:

• (ref) cameraPosition (Microsoft.Xna.Framework.Vector3) –
• (ref) cameraTarget (Microsoft.Xna.Framework.Vector3) –
• (ref) cameraUpVector (Microsoft.Xna.Framework.Vector3) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

Matrix CreateOrthographic(float width, float height, float zNearPlane, float zFarPlane)

Creates a new projection T:Microsoft.Xna.Framework.Matrix for orthographic view.

Parameters:

• width (float) – Width of the viewing volume.
• height (float) – Height of the viewing volume.
• zNearPlane (float) – Depth of the near plane.
• zFarPlane (float) – Depth of the far plane.

Returns:

The new projection T:Microsoft.Xna.Framework.Matrix for orthographic view.

void CreateOrthographic(float width, float height, float zNearPlane, float zFarPlane, ref Matrix result)

Parameters:

• width (float) –
• height (float) –
• zNearPlane (float) –
• zFarPlane (float) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

Matrix CreateOrthographicOffCenter(float left, float right, float bottom, float top, float zNearPlane, float zFarPlane)

Creates a new projection T:Microsoft.Xna.Framework.Matrix for customized orthographic view.

Parameters:

• left (float) – Lower x-value at the near plane.
• right (float) – Upper x-value at the near plane.
• bottom (float) – Lower y-coordinate at the near plane.
• top (float) – Upper y-value at the near plane.
• zNearPlane (float) – Depth of the near plane.
• zFarPlane (float) – Depth of the far plane.

Returns:

The new projection T:Microsoft.Xna.Framework.Matrix for customized orthographic view.

Matrix CreateOrthographicOffCenter(Rectangle viewingVolume, float zNearPlane, float zFarPlane)

Creates a new projection T:Microsoft.Xna.Framework.Matrix for customized orthographic view.

Parameters:

• viewingVolume (Microsoft.Xna.Framework.Rectangle) – The viewing volume.
• zNearPlane (float) – Depth of the near plane.
• zFarPlane (float) – Depth of the far plane.

Returns:

The new projection T:Microsoft.Xna.Framework.Matrix for customized orthographic view.

void CreateOrthographicOffCenter(float left, float right, float bottom, float top, float zNearPlane, float zFarPlane, ref Matrix result)

Parameters:

• left (float) –
• right (float) –
• bottom (float) –
• top (float) –
• zNearPlane (float) –
• zFarPlane (float) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

Matrix CreatePerspective(float width, float height, float nearPlaneDistance, float farPlaneDistance)

Creates a new projection T:Microsoft.Xna.Framework.Matrix for perspective view.

Parameters:

• width (float) – Width of the viewing volume.
• height (float) – Height of the viewing volume.
• nearPlaneDistance (float) – Distance to the near plane.
• farPlaneDistance (float) – Distance to the far plane.

Returns:

The new projection T:Microsoft.Xna.Framework.Matrix for perspective view.

void CreatePerspective(float width, float height, float nearPlaneDistance, float farPlaneDistance, ref Matrix result)

Parameters:

• width (float) –
• height (float) –
• nearPlaneDistance (float) –
• farPlaneDistance (float) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

Matrix CreatePerspectiveFieldOfView(float fieldOfView, float aspectRatio, float nearPlaneDistance, float farPlaneDistance)

Creates a new projection T:Microsoft.Xna.Framework.Matrix for perspective view with field of view.

Parameters:

• fieldOfView (float) – Field of view in the y direction in radians.
• aspectRatio (float) – Width divided by height of the viewing volume.
• nearPlaneDistance (float) – Distance to the near plane.
• farPlaneDistance (float) – Distance to the far plane.

Returns:

The new projection T:Microsoft.Xna.Framework.Matrix for perspective view with FOV.

void CreatePerspectiveFieldOfView(float fieldOfView, float aspectRatio, float nearPlaneDistance, float farPlaneDistance, ref Matrix result)

Parameters:

• fieldOfView (float) –
• aspectRatio (float) –
• nearPlaneDistance (float) –
• farPlaneDistance (float) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

Matrix CreatePerspectiveOffCenter(float left, float right, float bottom, float top, float nearPlaneDistance, float farPlaneDistance)

Creates a new projection T:Microsoft.Xna.Framework.Matrix for customized perspective view.

Parameters:

• left (float) – Lower x-value at the near plane.
• right (float) – Upper x-value at the near plane.
• bottom (float) – Lower y-coordinate at the near plane.
• top (float) – Upper y-value at the near plane.
• nearPlaneDistance (float) – Distance to the near plane.
• farPlaneDistance (float) – Distance to the far plane.

Returns:

The new T:Microsoft.Xna.Framework.Matrix for customized perspective view.

Matrix CreatePerspectiveOffCenter(Rectangle viewingVolume, float nearPlaneDistance, float farPlaneDistance)

Creates a new projection T:Microsoft.Xna.Framework.Matrix for customized perspective view.

Parameters:

• viewingVolume (Microsoft.Xna.Framework.Rectangle) – The viewing volume.
• nearPlaneDistance (float) – Distance to the near plane.
• farPlaneDistance (float) – Distance to the far plane.

Returns:

The new T:Microsoft.Xna.Framework.Matrix for customized perspective view.

void CreatePerspectiveOffCenter(float left, float right, float bottom, float top, float nearPlaneDistance, float farPlaneDistance, ref Matrix result)

Parameters:

• left (float) –
• right (float) –
• bottom (float) –
• top (float) –
• nearPlaneDistance (float) –
• farPlaneDistance (float) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

Matrix CreateRotationX(float radians)

Creates a new rotation T:Microsoft.Xna.Framework.Matrix around X axis.

Parameters:

• radians (float) – Angle in radians.

Returns:

The rotation T:Microsoft.Xna.Framework.Matrix around X axis.

void CreateRotationX(float radians, ref Matrix result)

Parameters:

• radians (float) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

Matrix CreateRotationY(float radians)

Creates a new rotation T:Microsoft.Xna.Framework.Matrix around Y axis.

Parameters:

• radians (float) – Angle in radians.

Returns:

The rotation T:Microsoft.Xna.Framework.Matrix around Y axis.

void CreateRotationY(float radians, ref Matrix result)

Parameters:

• radians (float) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

Matrix CreateRotationZ(float radians)

Creates a new rotation T:Microsoft.Xna.Framework.Matrix around Z axis.

Parameters:

• radians (float) – Angle in radians.

Returns:

The rotation T:Microsoft.Xna.Framework.Matrix around Z axis.

void CreateRotationZ(float radians, ref Matrix result)

Parameters:

• radians (float) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

Matrix CreateScale(float scale)

Creates a new scaling T:Microsoft.Xna.Framework.Matrix.

Parameters:

• scale (float) – Scale value for all three axises.

Returns:

The scaling T:Microsoft.Xna.Framework.Matrix.

void CreateScale(float scale, ref Matrix result)

Parameters:

• scale (float) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

Matrix CreateScale(float xScale, float yScale, float zScale)

Creates a new scaling T:Microsoft.Xna.Framework.Matrix.

Parameters:

• xScale (float) – Scale value for X axis.
• yScale (float) – Scale value for Y axis.
• zScale (float) – Scale value for Z axis.

Returns:

The scaling T:Microsoft.Xna.Framework.Matrix.

void CreateScale(float xScale, float yScale, float zScale, ref Matrix result)

Parameters:

• xScale (float) –
• yScale (float) –
• zScale (float) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

Matrix CreateScale(Vector3 scales)

Creates a new scaling T:Microsoft.Xna.Framework.Matrix.

Parameters:

• scales (Microsoft.Xna.Framework.Vector3) – T:Microsoft.Xna.Framework.Vector3 representing x,y and z scale values.

Returns:

The scaling T:Microsoft.Xna.Framework.Matrix.

void CreateScale(ref Vector3 scales, ref Matrix result)

Parameters:

• (ref) scales (Microsoft.Xna.Framework.Vector3) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

Matrix CreateShadow(Vector3 lightDirection, Plane plane)

Creates a new T:Microsoft.Xna.Framework.Matrix that flattens geometry into a specified T:Microsoft.Xna.Framework.Plane as if casting a shadow from a specified light source.

Parameters:

• lightDirection (Microsoft.Xna.Framework.Vector3) – A vector specifying the direction from which the light that will cast the shadow is coming.
• plane (Microsoft.Xna.Framework.Plane) – The plane onto which the new matrix should flatten geometry so as to cast a shadow.

Returns:

A T:Microsoft.Xna.Framework.Matrix that can be used to flatten geometry onto the specified plane from the specified direction.

void CreateShadow(ref Vector3 lightDirection, ref Plane plane, ref Matrix result)

Parameters:

• (ref) lightDirection (Microsoft.Xna.Framework.Vector3) –
• (ref) plane (Microsoft.Xna.Framework.Plane) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

Matrix CreateTranslation(float xPosition, float yPosition, float zPosition)

Creates a new translation T:Microsoft.Xna.Framework.Matrix.

Parameters:

• xPosition (float) – X coordinate of translation.
• yPosition (float) – Y coordinate of translation.
• zPosition (float) – Z coordinate of translation.

Returns:

The translation T:Microsoft.Xna.Framework.Matrix.

void CreateTranslation(ref Vector3 position, ref Matrix result)

Parameters:

• (ref) position (Microsoft.Xna.Framework.Vector3) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

Matrix CreateTranslation(Vector3 position)

Creates a new translation T:Microsoft.Xna.Framework.Matrix.

Parameters:

• position (Microsoft.Xna.Framework.Vector3) – X,Y and Z coordinates of translation.

Returns:

The translation T:Microsoft.Xna.Framework.Matrix.

void CreateTranslation(float xPosition, float yPosition, float zPosition, ref Matrix result)

Parameters:

• xPosition (float) –
• yPosition (float) –
• zPosition (float) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

Matrix CreateReflection(Plane value)

Creates a new reflection T:Microsoft.Xna.Framework.Matrix.

Parameters:

• value (Microsoft.Xna.Framework.Plane) – The plane that used for reflection calculation.

Returns:

The reflection T:Microsoft.Xna.Framework.Matrix.

void CreateReflection(ref Plane value, ref Matrix result)

Parameters:

• (ref) value (Microsoft.Xna.Framework.Plane) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

Matrix CreateWorld(Vector3 position, Vector3 forward, Vector3 up)

Creates a new world T:Microsoft.Xna.Framework.Matrix.

Parameters:

• position (Microsoft.Xna.Framework.Vector3) – The position vector.
• forward (Microsoft.Xna.Framework.Vector3) – The forward direction vector.
• up (Microsoft.Xna.Framework.Vector3) – The upward direction vector. Usually P:Microsoft.Xna.Framework.Vector3.Up.

Returns:

The world T:Microsoft.Xna.Framework.Matrix.

void CreateWorld(ref Vector3 position, ref Vector3 forward, ref Vector3 up, ref Matrix result)

Parameters:

• (ref) position (Microsoft.Xna.Framework.Vector3) –
• (ref) forward (Microsoft.Xna.Framework.Vector3) –
• (ref) up (Microsoft.Xna.Framework.Vector3) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

bool Decompose(ref Vector3 scale, ref Quaternion rotation, ref Vector3 translation)

Parameters:

• (ref) scale (Microsoft.Xna.Framework.Vector3) –
• (ref) rotation (Microsoft.Xna.Framework.Quaternion) –
• (ref) translation (Microsoft.Xna.Framework.Vector3) –

float Determinant()

Returns a determinant of this T:Microsoft.Xna.Framework.Matrix.

Returns:Determinant of this T:Microsoft.Xna.Framework.Matrix

Matrix Divide(Matrix matrix1, Matrix matrix2)

Divides the elements of a T:Microsoft.Xna.Framework.Matrix by the elements of another matrix.

Parameters:

• matrix1 (Microsoft.Xna.Framework.Matrix) – Source T:Microsoft.Xna.Framework.Matrix.
• matrix2 (Microsoft.Xna.Framework.Matrix) – Divisor T:Microsoft.Xna.Framework.Matrix.

Returns:

The result of dividing the matrix.

void Divide(ref Matrix matrix1, ref Matrix matrix2, ref Matrix result)

Parameters:

• (ref) matrix1 (Microsoft.Xna.Framework.Matrix) –
• (ref) matrix2 (Microsoft.Xna.Framework.Matrix) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

Matrix Divide(Matrix matrix1, float divider)

Divides the elements of a T:Microsoft.Xna.Framework.Matrix by a scalar.

Parameters:

• matrix1 (Microsoft.Xna.Framework.Matrix) – Source T:Microsoft.Xna.Framework.Matrix.
• divider (float) – Divisor scalar.

Returns:

The result of dividing a matrix by a scalar.

void Divide(ref Matrix matrix1, float divider, ref Matrix result)

Parameters:

• (ref) matrix1 (Microsoft.Xna.Framework.Matrix) –
• divider (float) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

bool Equals(Matrix other)

Compares whether current instance is equal to specified T:Microsoft.Xna.Framework.Matrix without any tolerance.

Parameters:

• other (Microsoft.Xna.Framework.Matrix) – The T:Microsoft.Xna.Framework.Matrix to compare.

Returns:

true if the instances are equal; false otherwise.

bool Equals(System.Object obj)

Compares whether current instance is equal to specified T:System.Object without any tolerance.

Parameters:

• obj (System.Object) – The T:System.Object to compare.

Returns:

true if the instances are equal; false otherwise.

int GetHashCode()

Gets the hash code of this T:Microsoft.Xna.Framework.Matrix.

Returns:Hash code of this T:Microsoft.Xna.Framework.Matrix.

Matrix Invert(Matrix matrix)

Creates a new T:Microsoft.Xna.Framework.Matrix which contains inversion of the specified matrix.

Parameters:

• matrix (Microsoft.Xna.Framework.Matrix) – Source T:Microsoft.Xna.Framework.Matrix.

Returns:

The inverted matrix.

void Invert(ref Matrix matrix, ref Matrix result)

Parameters:

• (ref) matrix (Microsoft.Xna.Framework.Matrix) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

Matrix Lerp(Matrix matrix1, Matrix matrix2, float amount)

Creates a new T:Microsoft.Xna.Framework.Matrix that contains linear interpolation of the values in specified matrixes.

Parameters:

• matrix1 (Microsoft.Xna.Framework.Matrix) – The first T:Microsoft.Xna.Framework.Matrix.
• matrix2 (Microsoft.Xna.Framework.Matrix) – The second T:Microsoft.Xna.Framework.Vector2.
• amount (float) – Weighting value(between 0.0 and 1.0).

Returns:

>The result of linear interpolation of the specified matrixes.

void Lerp(ref Matrix matrix1, ref Matrix matrix2, float amount, ref Matrix result)

Parameters:

• (ref) matrix1 (Microsoft.Xna.Framework.Matrix) –
• (ref) matrix2 (Microsoft.Xna.Framework.Matrix) –
• amount (float) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

Matrix Multiply(Matrix matrix1, Matrix matrix2)

Creates a new T:Microsoft.Xna.Framework.Matrix that contains a multiplication of two matrix.

Parameters:

• matrix1 (Microsoft.Xna.Framework.Matrix) – Source T:Microsoft.Xna.Framework.Matrix.
• matrix2 (Microsoft.Xna.Framework.Matrix) – Source T:Microsoft.Xna.Framework.Matrix.

Returns:

Result of the matrix multiplication.

void Multiply(ref Matrix matrix1, ref Matrix matrix2, ref Matrix result)

Parameters:

• (ref) matrix1 (Microsoft.Xna.Framework.Matrix) –
• (ref) matrix2 (Microsoft.Xna.Framework.Matrix) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

Matrix Multiply(Matrix matrix1, float scaleFactor)

Creates a new T:Microsoft.Xna.Framework.Matrix that contains a multiplication of T:Microsoft.Xna.Framework.Matrix and a scalar.

Parameters:

• matrix1 (Microsoft.Xna.Framework.Matrix) – Source T:Microsoft.Xna.Framework.Matrix.
• scaleFactor (float) – Scalar value.

Returns:

Result of the matrix multiplication with a scalar.

void Multiply(ref Matrix matrix1, float scaleFactor, ref Matrix result)

Parameters:

• (ref) matrix1 (Microsoft.Xna.Framework.Matrix) –
• scaleFactor (float) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

System.Single[] ToFloatArray(Matrix matrix)

Copy the values of specified T:Microsoft.Xna.Framework.Matrix to the float array.

Parameters:

• matrix (Microsoft.Xna.Framework.Matrix) – The source T:Microsoft.Xna.Framework.Matrix.

Returns:

The array which matrix values will be stored.

Matrix Negate(Matrix matrix)

Returns a matrix with the all values negated.

Parameters:

• matrix (Microsoft.Xna.Framework.Matrix) – Source T:Microsoft.Xna.Framework.Matrix.

Returns:

Result of the matrix negation.

void Negate(ref Matrix matrix, ref Matrix result)

Parameters:

• (ref) matrix (Microsoft.Xna.Framework.Matrix) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

Matrix op_Addition(Matrix matrix1, Matrix matrix2)

Adds two matrixes.

Parameters:

• matrix1 (Microsoft.Xna.Framework.Matrix) – Source T:Microsoft.Xna.Framework.Matrix on the left of the add sign.
• matrix2 (Microsoft.Xna.Framework.Matrix) – Source T:Microsoft.Xna.Framework.Matrix on the right of the add sign.

Returns:

Sum of the matrixes.

Matrix op_Division(Matrix matrix1, Matrix matrix2)

Divides the elements of a T:Microsoft.Xna.Framework.Matrix by the elements of another T:Microsoft.Xna.Framework.Matrix.

Parameters:

• matrix1 (Microsoft.Xna.Framework.Matrix) – Source T:Microsoft.Xna.Framework.Matrix on the left of the div sign.
• matrix2 (Microsoft.Xna.Framework.Matrix) – Divisor T:Microsoft.Xna.Framework.Matrix on the right of the div sign.

Returns:

The result of dividing the matrixes.

Matrix op_Division(Matrix matrix, float divider)

Divides the elements of a T:Microsoft.Xna.Framework.Matrix by a scalar.

Parameters:

• matrix (Microsoft.Xna.Framework.Matrix) – Source T:Microsoft.Xna.Framework.Matrix on the left of the div sign.
• divider (float) – Divisor scalar on the right of the div sign.

Returns:

The result of dividing a matrix by a scalar.

bool op_Equality(Matrix matrix1, Matrix matrix2)

Compares whether two T:Microsoft.Xna.Framework.Matrix instances are equal without any tolerance.

Parameters:

• matrix1 (Microsoft.Xna.Framework.Matrix) – Source T:Microsoft.Xna.Framework.Matrix on the left of the equal sign.
• matrix2 (Microsoft.Xna.Framework.Matrix) – Source T:Microsoft.Xna.Framework.Matrix on the right of the equal sign.

Returns:

true if the instances are equal; false otherwise.

bool op_Inequality(Matrix matrix1, Matrix matrix2)

Compares whether two T:Microsoft.Xna.Framework.Matrix instances are not equal without any tolerance.

Parameters:

• matrix1 (Microsoft.Xna.Framework.Matrix) – Source T:Microsoft.Xna.Framework.Matrix on the left of the not equal sign.
• matrix2 (Microsoft.Xna.Framework.Matrix) – Source T:Microsoft.Xna.Framework.Matrix on the right of the not equal sign.

Returns:

true if the instances are not equal; false otherwise.

Matrix op_Multiply(Matrix matrix1, Matrix matrix2)

Multiplies two matrixes.

Parameters:

• matrix1 (Microsoft.Xna.Framework.Matrix) – Source T:Microsoft.Xna.Framework.Matrix on the left of the mul sign.
• matrix2 (Microsoft.Xna.Framework.Matrix) – Source T:Microsoft.Xna.Framework.Matrix on the right of the mul sign.

Returns:

Result of the matrix multiplication.

Matrix op_Multiply(Matrix matrix, float scaleFactor)

Multiplies the elements of matrix by a scalar.

Parameters:

• matrix (Microsoft.Xna.Framework.Matrix) – Source T:Microsoft.Xna.Framework.Matrix on the left of the mul sign.
• scaleFactor (float) – Scalar value on the right of the mul sign.

Returns:

Result of the matrix multiplication with a scalar.

Matrix op_Subtraction(Matrix matrix1, Matrix matrix2)

Subtracts the values of one T:Microsoft.Xna.Framework.Matrix from another T:Microsoft.Xna.Framework.Matrix.

Parameters:

• matrix1 (Microsoft.Xna.Framework.Matrix) – Source T:Microsoft.Xna.Framework.Matrix on the left of the sub sign.
• matrix2 (Microsoft.Xna.Framework.Matrix) – Source T:Microsoft.Xna.Framework.Matrix on the right of the sub sign.

Returns:

Result of the matrix subtraction.

Matrix op_UnaryNegation(Matrix matrix)

Inverts values in the specified T:Microsoft.Xna.Framework.Matrix.

Parameters:

• matrix (Microsoft.Xna.Framework.Matrix) – Source T:Microsoft.Xna.Framework.Matrix on the right of the sub sign.

Returns:

Result of the inversion.

Matrix Subtract(Matrix matrix1, Matrix matrix2)

Creates a new T:Microsoft.Xna.Framework.Matrix that contains subtraction of one matrix from another.

Parameters:

• matrix1 (Microsoft.Xna.Framework.Matrix) – The first T:Microsoft.Xna.Framework.Matrix.
• matrix2 (Microsoft.Xna.Framework.Matrix) – The second T:Microsoft.Xna.Framework.Matrix.

Returns:

The result of the matrix subtraction.

void Subtract(ref Matrix matrix1, ref Matrix matrix2, ref Matrix result)

Parameters:

• (ref) matrix1 (Microsoft.Xna.Framework.Matrix) –
• (ref) matrix2 (Microsoft.Xna.Framework.Matrix) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

string get_DebugDisplayString()

string ToString()

Returns a T:System.String representation of this T:Microsoft.Xna.Framework.Matrix in the format: {M11:[F:Microsoft.Xna.Framework.Matrix.M11] M12:[F:Microsoft.Xna.Framework.Matrix.M12] M13:[F:Microsoft.Xna.Framework.Matrix.M13] M14:[F:Microsoft.Xna.Framework.Matrix.M14]} {M21:[F:Microsoft.Xna.Framework.Matrix.M21] M12:[F:Microsoft.Xna.Framework.Matrix.M22] M13:[F:Microsoft.Xna.Framework.Matrix.M23] M14:[F:Microsoft.Xna.Framework.Matrix.M24]} {M31:[F:Microsoft.Xna.Framework.Matrix.M31] M32:[F:Microsoft.Xna.Framework.Matrix.M32] M33:[F:Microsoft.Xna.Framework.Matrix.M33] M34:[F:Microsoft.Xna.Framework.Matrix.M34]} {M41:[F:Microsoft.Xna.Framework.Matrix.M41] M42:[F:Microsoft.Xna.Framework.Matrix.M42] M43:[F:Microsoft.Xna.Framework.Matrix.M43] M44:[F:Microsoft.Xna.Framework.Matrix.M44]}

Returns:A T:System.String representation of this T:Microsoft.Xna.Framework.Matrix.

Matrix Transpose(Matrix matrix)

Swap the matrix rows and columns.

Parameters:

• matrix (Microsoft.Xna.Framework.Matrix) – The matrix for transposing operation.

Returns:

The new T:Microsoft.Xna.Framework.Matrix which contains the transposing result.

void Transpose(ref Matrix matrix, ref Matrix result)

Parameters:

• (ref) matrix (Microsoft.Xna.Framework.Matrix) –
• (ref) result (Microsoft.Xna.Framework.Matrix) –

MediaLibrary

class MediaLibrary : System.Object, System.IDisposable

readonly AlbumCollection Albums

readonly bool IsDisposed

readonly MediaSource MediaSource

readonly SongCollection Songs

public void Load(System.Action<Int32> progressCallback)

Load the contents of MediaLibrary. This blocking call might take up to a few minutes depending on the platform and the size of the user’s music library.

Parameters:

• progressCallback (System.Action<Int32>) – Callback that reports back the progress of the music library loading in percents (0-100).

public void Dispose()

MediaPlayer

class MediaPlayer : System.Object

readonly MediaQueue Queue

bool IsMuted

bool IsRepeating

bool IsShuffled

readonly bool IsVisualizationEnabled

readonly System.TimeSpan PlayPosition

readonly MediaState State

readonly bool GameHasControl

float Volume

public void add_ActiveSongChanged(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_ActiveSongChanged(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void add_MediaStateChanged(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_MediaStateChanged(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void Pause()

public void Play(Song song)

Play clears the current playback queue, and then queues up the specified song for playback. Playback starts immediately at the beginning of the song.

Parameters:

• song (Microsoft.Xna.Framework.Media.Song) –

public void Play(Song song, System.Nullable<TimeSpan> startPosition)

Play clears the current playback queue, and then queues up the specified song for playback. Playback starts immediately at the given position of the song.

Parameters:

• song (Microsoft.Xna.Framework.Media.Song) –
• startPosition (System.Nullable<TimeSpan>) –

public void Play(SongCollection collection, int index)

Parameters:

• collection (Microsoft.Xna.Framework.Media.SongCollection) –
• index (int) –

void OnSongFinishedPlaying(System.Object sender, System.EventArgs args)

Parameters:

• sender (System.Object) –
• args (System.EventArgs) –

public void Resume()

public void Stop()

public void MoveNext()

public void MovePrevious()

MediaQueue

class MediaQueue : System.Object

readonly Song ActiveSong

int ActiveSongIndex

readonly Song Item

int get_Count()

System.Collections.Generic.IEnumerable<Song> get_Songs()

Song GetNextSong(int direction, bool shuffle)

Parameters:

• direction (int) –
• shuffle (bool) –

void Clear()

void Add(Song song)

Parameters:

• song (Microsoft.Xna.Framework.Media.Song) –

MediaSource

class MediaSource : System.Object

readonly MediaSourceType MediaSourceType

readonly string Name

public System.Collections.Generic.IList<MediaSource> GetAvailableMediaSources()

MediaSourceType

enum MediaSourceType : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

MediaSourceType LocalDevice

MediaSourceType WindowsMediaConnect

MediaState

enum MediaState : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

MediaState Stopped

MediaState Playing

MediaState Paused

Model

class Model : System.Object

A basic 3D model with per mesh parent bones.

readonly ModelBoneCollection Bones

A collection of T:Microsoft.Xna.Framework.Graphics.ModelBone objects which describe how each mesh in the mesh collection for this model relates to its parent mesh.

readonly ModelMeshCollection Meshes

A collection of T:Microsoft.Xna.Framework.Graphics.ModelMesh objects which compose the model. Each T:Microsoft.Xna.Framework.Graphics.ModelMesh in a model may be moved independently and may be composed of multiple materials identified as T:Microsoft.Xna.Framework.Graphics.ModelMeshPart objects.

ModelBone Root

Root bone for this model.

System.Object Tag

Custom attached object.

Skinning data is example of attached object for model.

void BuildHierarchy()

public void Draw(Matrix world, Matrix view, Matrix projection)

Draws the model meshes.

Parameters:

• world (Microsoft.Xna.Framework.Matrix) – The world transform.
• view (Microsoft.Xna.Framework.Matrix) – The view transform.
• projection (Microsoft.Xna.Framework.Matrix) – The projection transform.

public void CopyAbsoluteBoneTransformsTo(Microsoft.Xna.Framework.Matrix[] destinationBoneTransforms)

Copies bone transforms relative to all parent bones of the each bone from this model to a given array.

Parameters:

• destinationBoneTransforms (Microsoft.Xna.Framework.Matrix[]) – The array receiving the transformed bones.

public void CopyBoneTransformsFrom(Microsoft.Xna.Framework.Matrix[] sourceBoneTransforms)

Copies bone transforms relative to P:Microsoft.Xna.Framework.Graphics.Model.Root bone from a given array to this model.

Parameters:

• sourceBoneTransforms (Microsoft.Xna.Framework.Matrix[]) – The array of prepared bone transform data.

public void CopyBoneTransformsTo(Microsoft.Xna.Framework.Matrix[] destinationBoneTransforms)

Copies bone transforms relative to P:Microsoft.Xna.Framework.Graphics.Model.Root bone from this model to a given array.

Parameters:

• destinationBoneTransforms (Microsoft.Xna.Framework.Matrix[]) – The array receiving the transformed bones.

ModelBone

class ModelBone : System.Object

readonly System.Collections.Generic.List<ModelMesh> Meshes

readonly ModelBoneCollection Children

int Index

string Name

ModelBone Parent

Matrix Transform

Matrix ModelTransform

Transform of this node from the root of the model not from the parent

public void AddMesh(ModelMesh mesh)

Parameters:

• mesh (Microsoft.Xna.Framework.Graphics.ModelMesh) –

public void AddChild(ModelBone modelBone)

Parameters:

• modelBone (Microsoft.Xna.Framework.Graphics.ModelBone) –

ModelBoneCollection

class ModelBoneCollection : System.Collections.ObjectModel.ReadOnlyCollection<ModelBone>, System.Collections.Generic.IList<ModelBone>, System.Collections.Generic.ICollection<ModelBone>, System.Collections.Generic.IEnumerable<ModelBone>, System.Collections.IEnumerable, System.Collections.IList, System.Collections.ICollection, System.Collections.Generic.IReadOnlyList<ModelBone>, System.Collections.Generic.IReadOnlyCollection<ModelBone>

Represents a set of bones associated with a model.

readonly ModelBone Item

public bool TryGetValue(string boneName, ref ModelBone value)

Parameters:

• boneName (string) –
• (ref) value (Microsoft.Xna.Framework.Graphics.ModelBone) –

public Microsoft.Xna.Framework.Graphics.Enumerator GetEnumerator()

Returns a ModelMeshCollection.Enumerator that can iterate through a ModelMeshCollection.

Returns:

ModelEffectCollection

class ModelEffectCollection : System.Collections.ObjectModel.ReadOnlyCollection<Effect>, System.Collections.Generic.IList<Effect>, System.Collections.Generic.ICollection<Effect>, System.Collections.Generic.IEnumerable<Effect>, System.Collections.IEnumerable, System.Collections.IList, System.Collections.ICollection, System.Collections.Generic.IReadOnlyList<Effect>, System.Collections.Generic.IReadOnlyCollection<Effect>

void Add(Effect item)

Parameters:

• item (Microsoft.Xna.Framework.Graphics.Effect) –

void Remove(Effect item)

Parameters:

• item (Microsoft.Xna.Framework.Graphics.Effect) –

public Microsoft.Xna.Framework.Graphics.Enumerator GetEnumerator()

ModelMesh

class ModelMesh : System.Object

BoundingSphere BoundingSphere

ModelEffectCollection Effects

ModelMeshPartCollection MeshParts

string Name

ModelBone ParentBone

System.Object Tag

public void Draw()

ModelMeshCollection

class ModelMeshCollection : System.Collections.ObjectModel.ReadOnlyCollection<ModelMesh>, System.Collections.Generic.IList<ModelMesh>, System.Collections.Generic.ICollection<ModelMesh>, System.Collections.Generic.IEnumerable<ModelMesh>, System.Collections.IEnumerable, System.Collections.IList, System.Collections.ICollection, System.Collections.Generic.IReadOnlyList<ModelMesh>, System.Collections.Generic.IReadOnlyCollection<ModelMesh>

Represents a collection of ModelMesh objects.

readonly ModelMesh Item

public bool TryGetValue(string meshName, ref ModelMesh value)

Parameters:

• meshName (string) –
• (ref) value (Microsoft.Xna.Framework.Graphics.ModelMesh) –

public Microsoft.Xna.Framework.Graphics.Enumerator GetEnumerator()

Returns a ModelMeshCollection.Enumerator that can iterate through a ModelMeshCollection.

Returns:

ModelMeshPart

class ModelMeshPart : System.Object

Effect Effect

IndexBuffer IndexBuffer

int NumVertices

int PrimitiveCount

int StartIndex

System.Object Tag

VertexBuffer VertexBuffer

int VertexOffset

int get_VertexBufferIndex()

void set_VertexBufferIndex(int value)

Parameters:

• value (int) –

int get_IndexBufferIndex()

void set_IndexBufferIndex(int value)

Parameters:

• value (int) –

int get_EffectIndex()

void set_EffectIndex(int value)

Parameters:

• value (int) –

ModelMeshPartCollection

class ModelMeshPartCollection : System.Collections.ObjectModel.ReadOnlyCollection<ModelMeshPart>, System.Collections.Generic.IList<ModelMeshPart>, System.Collections.Generic.ICollection<ModelMeshPart>, System.Collections.Generic.IEnumerable<ModelMeshPart>, System.Collections.IEnumerable, System.Collections.IList, System.Collections.ICollection, System.Collections.Generic.IReadOnlyList<ModelMeshPart>, System.Collections.Generic.IReadOnlyCollection<ModelMeshPart>

Mouse

class Mouse : System.Object

Allows reading position and button click information from mouse.

System.IntPtr WindowHandle

Gets or sets the window handle for current mouse processing.

public MouseState GetState(GameWindow window)

This API is an extension to XNA. Gets mouse state information that includes position and button presses for the provided window

Parameters:

• window (Microsoft.Xna.Framework.GameWindow) –

Returns:

Current state of the mouse.

public MouseState GetState()

Gets mouse state information that includes position and button presses for the primary window

Returns:Current state of the mouse.

public void SetPosition(int x, int y)

Sets mouse cursor’s relative position to game-window.

Parameters:

• x (int) – Relative horizontal position of the cursor.
• y (int) – Relative vertical position of the cursor.

public void SetCursor(MouseCursor cursor)

Sets the cursor image to the specified MouseCursor.

Parameters:

• cursor (Microsoft.Xna.Framework.Input.MouseCursor) – Mouse cursor to use for the cursor image.

public void PlatformSetCursor(MouseCursor cursor)

Parameters:

• cursor (Microsoft.Xna.Framework.Input.MouseCursor) –

MouseCursor

class MouseCursor : System.Object, System.IDisposable

Describes a mouse cursor.

readonly MouseCursor Arrow

Gets the default arrow cursor.

readonly MouseCursor IBeam

Gets the cursor that appears when the mouse is over text editing regions.

readonly MouseCursor Wait

Gets the waiting cursor that appears while the application/system is busy.

readonly MouseCursor Crosshair

Gets the crosshair (“+”) cursor.

readonly MouseCursor WaitArrow

Gets the cross between Arrow and Wait cursors.

readonly MouseCursor SizeNWSE

Gets the northwest/southeast (“”) cursor.

readonly MouseCursor SizeNESW

Gets the northeast/southwest (“/”) cursor.

readonly MouseCursor SizeWE

Gets the horizontal west/east (“-”) cursor.

readonly MouseCursor SizeNS

Gets the vertical north/south (“|”) cursor.

readonly MouseCursor SizeAll

Gets the size all cursor which points in all directions.

readonly MouseCursor No

Gets the cursor that points that something is invalid, usually a cross.

readonly MouseCursor Hand

Gets the hand cursor, usually used for web links.

readonly System.IntPtr Handle

public MouseCursor FromTexture2D(Texture2D texture, int originx, int originy)

Creates a mouse cursor from the specified texture.

Parameters:

• texture (Microsoft.Xna.Framework.Graphics.Texture2D) – Texture to use as the cursor image.
• originx (int) – X cordinate of the image that will be used for mouse position.
• originy (int) – Y cordinate of the image that will be used for mouse position.

public void Dispose()

MouseState

struct MouseState : System.ValueType

Represents a mouse state with cursor position and button press information.

readonly int X

Gets horizontal position of the cursor in relation to the window.

readonly int Y

Gets vertical position of the cursor in relation to the window.

readonly Point Position

Gets cursor position.

readonly ButtonState LeftButton

Gets state of the left mouse button.

readonly ButtonState MiddleButton

Gets state of the middle mouse button.

readonly ButtonState RightButton

Gets state of the right mouse button.

readonly int ScrollWheelValue

Returns cumulative scroll wheel value since the game start.

readonly ButtonState XButton1

Gets state of the XButton1.

readonly ButtonState XButton2

Gets state of the XButton2.

bool op_Equality(MouseState left, MouseState right)

Compares whether two MouseState instances are equal.

Parameters:

• left (Microsoft.Xna.Framework.Input.MouseState) – MouseState instance on the left of the equal sign.
• right (Microsoft.Xna.Framework.Input.MouseState) – MouseState instance on the right of the equal sign.

Returns:

true if the instances are equal; false otherwise.

bool op_Inequality(MouseState left, MouseState right)

Compares whether two MouseState instances are not equal.

Parameters:

• left (Microsoft.Xna.Framework.Input.MouseState) – MouseState instance on the left of the equal sign.
• right (Microsoft.Xna.Framework.Input.MouseState) – MouseState instance on the right of the equal sign.

Returns:

true if the objects are not equal; false otherwise.

bool Equals(System.Object obj)

Compares whether current instance is equal to specified object.

Parameters:

• obj (System.Object) – The MouseState to compare.

Returns:

int GetHashCode()

Gets the hash code for MouseState instance.

Returns:Hash code of the object.

void set_X(int value)

Parameters:

• value (int) –

void set_Y(int value)

Parameters:

• value (int) –

void set_LeftButton(ButtonState value)

Parameters:

• value (Microsoft.Xna.Framework.Input.ButtonState) –

void set_MiddleButton(ButtonState value)

Parameters:

• value (Microsoft.Xna.Framework.Input.ButtonState) –

void set_RightButton(ButtonState value)

Parameters:

• value (Microsoft.Xna.Framework.Input.ButtonState) –

void set_ScrollWheelValue(int value)

Parameters:

• value (int) –

void set_XButton1(ButtonState value)

Parameters:

• value (Microsoft.Xna.Framework.Input.ButtonState) –

void set_XButton2(ButtonState value)

Parameters:

• value (Microsoft.Xna.Framework.Input.ButtonState) –

NoAudioHardwareException

class NoAudioHardwareException : System.Runtime.InteropServices.ExternalException, System.Runtime.Serialization.ISerializable, System.Runtime.InteropServices._Exception

The exception thrown when no audio hardware is present, or driver issues are detected.

NormalizedByte2

struct NormalizedByte2 : System.ValueType, Microsoft.Xna.Framework.Graphics.PackedVector.IPackedVector<UInt16>, IPackedVector, System.IEquatable<NormalizedByte2>

ushort PackedValue

bool op_Inequality(NormalizedByte2 a, NormalizedByte2 b)

Parameters:

• a (Microsoft.Xna.Framework.Graphics.PackedVector.NormalizedByte2) –
• b (Microsoft.Xna.Framework.Graphics.PackedVector.NormalizedByte2) –

bool op_Equality(NormalizedByte2 a, NormalizedByte2 b)

Parameters:

• a (Microsoft.Xna.Framework.Graphics.PackedVector.NormalizedByte2) –
• b (Microsoft.Xna.Framework.Graphics.PackedVector.NormalizedByte2) –

bool Equals(System.Object obj)

Parameters:

• obj (System.Object) –

bool Equals(NormalizedByte2 other)

Parameters:

• other (Microsoft.Xna.Framework.Graphics.PackedVector.NormalizedByte2) –

int GetHashCode()

string ToString()

Vector2 ToVector2()

NormalizedByte4

struct NormalizedByte4 : System.ValueType, Microsoft.Xna.Framework.Graphics.PackedVector.IPackedVector<UInt32>, IPackedVector, System.IEquatable<NormalizedByte4>

uint PackedValue

bool op_Inequality(NormalizedByte4 a, NormalizedByte4 b)

Parameters:

• a (Microsoft.Xna.Framework.Graphics.PackedVector.NormalizedByte4) –
• b (Microsoft.Xna.Framework.Graphics.PackedVector.NormalizedByte4) –

bool op_Equality(NormalizedByte4 a, NormalizedByte4 b)

Parameters:

• a (Microsoft.Xna.Framework.Graphics.PackedVector.NormalizedByte4) –
• b (Microsoft.Xna.Framework.Graphics.PackedVector.NormalizedByte4) –

bool Equals(System.Object obj)

Parameters:

• obj (System.Object) –

bool Equals(NormalizedByte4 other)

Parameters:

• other (Microsoft.Xna.Framework.Graphics.PackedVector.NormalizedByte4) –

int GetHashCode()

string ToString()

Vector4 ToVector4()

NormalizedShort2

struct NormalizedShort2 : System.ValueType, Microsoft.Xna.Framework.Graphics.PackedVector.IPackedVector<UInt32>, IPackedVector, System.IEquatable<NormalizedShort2>

uint PackedValue

bool op_Inequality(NormalizedShort2 a, NormalizedShort2 b)

Parameters:

• a (Microsoft.Xna.Framework.Graphics.PackedVector.NormalizedShort2) –
• b (Microsoft.Xna.Framework.Graphics.PackedVector.NormalizedShort2) –

bool op_Equality(NormalizedShort2 a, NormalizedShort2 b)

Parameters:

• a (Microsoft.Xna.Framework.Graphics.PackedVector.NormalizedShort2) –
• b (Microsoft.Xna.Framework.Graphics.PackedVector.NormalizedShort2) –

bool Equals(System.Object obj)

Parameters:

• obj (System.Object) –

bool Equals(NormalizedShort2 other)

Parameters:

• other (Microsoft.Xna.Framework.Graphics.PackedVector.NormalizedShort2) –

int GetHashCode()

string ToString()

Vector2 ToVector2()

NormalizedShort4

struct NormalizedShort4 : System.ValueType, Microsoft.Xna.Framework.Graphics.PackedVector.IPackedVector<UInt64>, IPackedVector, System.IEquatable<NormalizedShort4>

ulong PackedValue

bool op_Inequality(NormalizedShort4 a, NormalizedShort4 b)

Parameters:

• a (Microsoft.Xna.Framework.Graphics.PackedVector.NormalizedShort4) –
• b (Microsoft.Xna.Framework.Graphics.PackedVector.NormalizedShort4) –

bool op_Equality(NormalizedShort4 a, NormalizedShort4 b)

Parameters:

• a (Microsoft.Xna.Framework.Graphics.PackedVector.NormalizedShort4) –
• b (Microsoft.Xna.Framework.Graphics.PackedVector.NormalizedShort4) –

bool Equals(System.Object obj)

Parameters:

• obj (System.Object) –

bool Equals(NormalizedShort4 other)

Parameters:

• other (Microsoft.Xna.Framework.Graphics.PackedVector.NormalizedShort4) –

int GetHashCode()

string ToString()

Vector4 ToVector4()

NoSuitableGraphicsDeviceException

class NoSuitableGraphicsDeviceException : System.Exception, System.Runtime.Serialization.ISerializable, System.Runtime.InteropServices._Exception

OcclusionQuery

class OcclusionQuery : GraphicsResource, System.IDisposable

readonly bool IsComplete

Gets a value indicating whether the occlusion query has completed.

Value:

:ref:`` if the occlusion query has completed; otherwise,

:ref:``.

readonly int PixelCount

Gets the number of visible pixels.

Value:The number of visible pixels.

public void Begin()

Begins the occlusion query.

public void End()

Ends the occlusion query.

Plane

struct Plane : System.ValueType, System.IEquatable<Plane>

float D

Vector3 Normal

float Dot(Vector4 value)

Parameters:

• value (Microsoft.Xna.Framework.Vector4) –

void Dot(ref Vector4 value, ref float result)

Parameters:

• (ref) value (Microsoft.Xna.Framework.Vector4) –
• (ref) result (float) –

float DotCoordinate(Vector3 value)

Parameters:

• value (Microsoft.Xna.Framework.Vector3) –

void DotCoordinate(ref Vector3 value, ref float result)

Parameters:

• (ref) value (Microsoft.Xna.Framework.Vector3) –
• (ref) result (float) –

float DotNormal(Vector3 value)

Parameters:

• value (Microsoft.Xna.Framework.Vector3) –

void DotNormal(ref Vector3 value, ref float result)

Parameters:

• (ref) value (Microsoft.Xna.Framework.Vector3) –
• (ref) result (float) –

Plane Transform(Plane plane, Matrix matrix)

Transforms a normalized plane by a matrix.

Parameters:

• plane (Microsoft.Xna.Framework.Plane) – The normalized plane to transform.
• matrix (Microsoft.Xna.Framework.Matrix) – The transformation matrix.

Returns:

The transformed plane.

void Transform(ref Plane plane, ref Matrix matrix, ref Plane result)

Parameters:

• (ref) plane (Microsoft.Xna.Framework.Plane) –
• (ref) matrix (Microsoft.Xna.Framework.Matrix) –
• (ref) result (Microsoft.Xna.Framework.Plane) –

Plane Transform(Plane plane, Quaternion rotation)

Transforms a normalized plane by a quaternion rotation.

Parameters:

• plane (Microsoft.Xna.Framework.Plane) – The normalized plane to transform.
• rotation (Microsoft.Xna.Framework.Quaternion) – The quaternion rotation.

Returns:

The transformed plane.

void Transform(ref Plane plane, ref Quaternion rotation, ref Plane result)

Parameters:

• (ref) plane (Microsoft.Xna.Framework.Plane) –
• (ref) rotation (Microsoft.Xna.Framework.Quaternion) –
• (ref) result (Microsoft.Xna.Framework.Plane) –

void Normalize()

Plane Normalize(Plane value)

Parameters:

• value (Microsoft.Xna.Framework.Plane) –

void Normalize(ref Plane value, ref Plane result)

Parameters:

• (ref) value (Microsoft.Xna.Framework.Plane) –
• (ref) result (Microsoft.Xna.Framework.Plane) –

bool op_Inequality(Plane plane1, Plane plane2)

Parameters:

• plane1 (Microsoft.Xna.Framework.Plane) –
• plane2 (Microsoft.Xna.Framework.Plane) –

bool op_Equality(Plane plane1, Plane plane2)

Parameters:

• plane1 (Microsoft.Xna.Framework.Plane) –
• plane2 (Microsoft.Xna.Framework.Plane) –

bool Equals(System.Object other)

Parameters:

• other (System.Object) –

bool Equals(Plane other)

Parameters:

• other (Microsoft.Xna.Framework.Plane) –

int GetHashCode()

PlaneIntersectionType Intersects(BoundingBox box)

Parameters:

• box (Microsoft.Xna.Framework.BoundingBox) –

void Intersects(ref BoundingBox box, ref PlaneIntersectionType result)

Parameters:

• (ref) box (Microsoft.Xna.Framework.BoundingBox) –
• (ref) result (Microsoft.Xna.Framework.PlaneIntersectionType) –

PlaneIntersectionType Intersects(BoundingFrustum frustum)

Parameters:

• frustum (Microsoft.Xna.Framework.BoundingFrustum) –

PlaneIntersectionType Intersects(BoundingSphere sphere)

Parameters:

• sphere (Microsoft.Xna.Framework.BoundingSphere) –

void Intersects(ref BoundingSphere sphere, ref PlaneIntersectionType result)

Parameters:

• (ref) sphere (Microsoft.Xna.Framework.BoundingSphere) –
• (ref) result (Microsoft.Xna.Framework.PlaneIntersectionType) –

PlaneIntersectionType Intersects(ref Vector3 point)

Parameters:

• (ref) point (Microsoft.Xna.Framework.Vector3) –

string get_DebugDisplayString()

string ToString()

PlaneIntersectionType

enum PlaneIntersectionType : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines the intersection between a T:Microsoft.Xna.Framework.Plane and a bounding volume.

PlaneIntersectionType Front

There is no intersection, the bounding volume is in the negative half space of the plane.

PlaneIntersectionType Back

There is no intersection, the bounding volume is in the positive half space of the plane.

PlaneIntersectionType Intersecting

The plane is intersected.

PlayerIndex

enum PlayerIndex : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines the index of player for various MonoGame components.

PlayerIndex One

The first player index.

PlayerIndex Two

The second player index.

PlayerIndex Three

The third player index.

PlayerIndex Four

The fourth player index.

Playlist

class Playlist : System.Object, System.IDisposable

readonly System.TimeSpan Duration

readonly string Name

void set_Duration(System.TimeSpan value)

Parameters:

• value (System.TimeSpan) –

void set_Name(string value)

Parameters:

• value (string) –

public void Dispose()

PlaylistCollection

class PlaylistCollection : System.Object, System.Collections.Generic.ICollection<Playlist>, System.Collections.Generic.IEnumerable<Playlist>, System.Collections.IEnumerable, System.IDisposable

readonly int Count

readonly bool IsReadOnly

readonly Playlist Item

public void Dispose()

public System.Collections.Generic.IEnumerator<Playlist> GetEnumerator()

public void Add(Playlist item)

Parameters:

• item (Microsoft.Xna.Framework.Media.Playlist) –

public void Clear()

public PlaylistCollection Clone()

public bool Contains(Playlist item)

Parameters:

• item (Microsoft.Xna.Framework.Media.Playlist) –

public void CopyTo(Microsoft.Xna.Framework.Media.Playlist[] array, int arrayIndex)

Parameters:

• array (Microsoft.Xna.Framework.Media.Playlist[]) –
• arrayIndex (int) –

public int IndexOf(Playlist item)

Parameters:

• item (Microsoft.Xna.Framework.Media.Playlist) –

public bool Remove(Playlist item)

Parameters:

• item (Microsoft.Xna.Framework.Media.Playlist) –

PngReader

class PngReader : System.Object

public Texture2D Read(System.IO.Stream inputStream, GraphicsDevice graphicsDevice)

Parameters:

• inputStream (System.IO.Stream) –
• graphicsDevice (Microsoft.Xna.Framework.Graphics.GraphicsDevice) –

public bool IsPngImage(System.IO.Stream stream)

Parameters:

• stream (System.IO.Stream) –

PngWriter

class PngWriter : System.Object

public void Write(Texture2D texture2D, System.IO.Stream outputStream)

Parameters:

• texture2D (Microsoft.Xna.Framework.Graphics.Texture2D) –
• outputStream (System.IO.Stream) –

Point

struct Point : System.ValueType, System.IEquatable<Point>

Describes a 2D-point.

int X

The x coordinate of this T:Microsoft.Xna.Framework.Point.

int Y

The y coordinate of this T:Microsoft.Xna.Framework.Point.

readonly Point Zero

Returns a T:Microsoft.Xna.Framework.Point with coordinates 0, 0.

string get_DebugDisplayString()

Point op_Addition(Point value1, Point value2)

Adds two points.

Parameters:

• value1 (Microsoft.Xna.Framework.Point) – Source T:Microsoft.Xna.Framework.Point on the left of the add sign.
• value2 (Microsoft.Xna.Framework.Point) – Source T:Microsoft.Xna.Framework.Point on the right of the add sign.

Returns:

Sum of the points.

Point op_Subtraction(Point value1, Point value2)

Subtracts a T:Microsoft.Xna.Framework.Point from a T:Microsoft.Xna.Framework.Point.

Parameters:

• value1 (Microsoft.Xna.Framework.Point) – Source T:Microsoft.Xna.Framework.Point on the left of the sub sign.
• value2 (Microsoft.Xna.Framework.Point) – Source T:Microsoft.Xna.Framework.Point on the right of the sub sign.

Returns:

Result of the subtraction.

Point op_Multiply(Point value1, Point value2)

Multiplies the components of two points by each other.

Parameters:

• value1 (Microsoft.Xna.Framework.Point) – Source T:Microsoft.Xna.Framework.Point on the left of the mul sign.
• value2 (Microsoft.Xna.Framework.Point) – Source T:Microsoft.Xna.Framework.Point on the right of the mul sign.

Returns:

Result of the multiplication.

Point op_Division(Point source, Point divisor)

Divides the components of a T:Microsoft.Xna.Framework.Point by the components of another T:Microsoft.Xna.Framework.Point.

Parameters:

• source (Microsoft.Xna.Framework.Point) – Source T:Microsoft.Xna.Framework.Point on the left of the div sign.
• divisor (Microsoft.Xna.Framework.Point) – Divisor T:Microsoft.Xna.Framework.Point on the right of the div sign.

Returns:

The result of dividing the points.

bool op_Equality(Point a, Point b)

Compares whether two T:Microsoft.Xna.Framework.Point instances are equal.

Parameters:

• a (Microsoft.Xna.Framework.Point) – T:Microsoft.Xna.Framework.Point instance on the left of the equal sign.
• b (Microsoft.Xna.Framework.Point) – T:Microsoft.Xna.Framework.Point instance on the right of the equal sign.

Returns:

true if the instances are equal; false otherwise.

bool op_Inequality(Point a, Point b)

Compares whether two T:Microsoft.Xna.Framework.Point instances are not equal.

Parameters:

• a (Microsoft.Xna.Framework.Point) – T:Microsoft.Xna.Framework.Point instance on the left of the not equal sign.
• b (Microsoft.Xna.Framework.Point) – T:Microsoft.Xna.Framework.Point instance on the right of the not equal sign.

Returns:

true if the instances are not equal; false otherwise.

bool Equals(System.Object obj)

Compares whether current instance is equal to specified T:System.Object.

Parameters:

• obj (System.Object) – The T:System.Object to compare.

Returns:

true if the instances are equal; false otherwise.

bool Equals(Point other)

Compares whether current instance is equal to specified T:Microsoft.Xna.Framework.Point.

Parameters:

• other (Microsoft.Xna.Framework.Point) – The T:Microsoft.Xna.Framework.Point to compare.

Returns:

true if the instances are equal; false otherwise.

int GetHashCode()

Gets the hash code of this T:Microsoft.Xna.Framework.Point.

Returns:Hash code of this T:Microsoft.Xna.Framework.Point.

string ToString()

Returns a T:System.String representation of this T:Microsoft.Xna.Framework.Point in the format: {X:[F:Microsoft.Xna.Framework.Point.X] Y:[F:Microsoft.Xna.Framework.Point.Y]}

Returns:T:System.String representation of this T:Microsoft.Xna.Framework.Point.

Vector2 ToVector2()

Gets a T:Microsoft.Xna.Framework.Vector2 representation for this object.

Returns:A T:Microsoft.Xna.Framework.Vector2 representation for this object.

PreparingDeviceSettingsEventArgs

class PreparingDeviceSettingsEventArgs : System.EventArgs

The arguments to the E:Microsoft.Xna.Framework.GraphicsDeviceManager.PreparingDeviceSettings event.

readonly GraphicsDeviceInformation GraphicsDeviceInformation

The default settings that will be used in device creation.

PresentationParameters

class PresentationParameters : System.Object, System.IDisposable

int DefaultPresentRate

SurfaceFormat BackBufferFormat

int BackBufferHeight

int BackBufferWidth

readonly Rectangle Bounds

System.IntPtr DeviceWindowHandle

DepthFormat DepthStencilFormat

bool IsFullScreen

int MultiSampleCount

PresentInterval PresentationInterval

DisplayOrientation DisplayOrientation

RenderTargetUsage RenderTargetUsage

public void Clear()

public PresentationParameters Clone()

public void Dispose()

PresentInterval

enum PresentInterval : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines how M:Microsoft.Xna.Framework.Graphics.GraphicsDevice.Present updates the game window.

PresentInterval Default

Equivalent to F:Microsoft.Xna.Framework.Graphics.PresentInterval.One.

PresentInterval One

The driver waits for the vertical retrace period, before updating window client area. Present operations are not affected more frequently than the screen refresh rate.

PresentInterval Two

The driver waits for the vertical retrace period, before updating window client area. Present operations are not affected more frequently than every second screen refresh.

PresentInterval Immediate

The driver updates the window client area immediately. Present operations might be affected immediately. There is no limit for framerate.

PrimitiveType

enum PrimitiveType : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines how vertex data is ordered.

PrimitiveType TriangleList

Renders the specified vertices as a sequence of isolated triangles. Each group of three vertices defines a separate triangle. Back-face culling is affected by the current winding-order render state.

PrimitiveType TriangleStrip

Renders the vertices as a triangle strip. The back-face culling flag is flipped automatically on even-numbered triangles.

PrimitiveType LineList

Renders the vertices as a list of isolated straight line segments; the count may be any positive integer.

PrimitiveType LineStrip

Renders the vertices as a single polyline; the count may be any positive integer.

Quaternion

struct Quaternion : System.ValueType, System.IEquatable<Quaternion>

An efficient mathematical representation for three dimensional rotations.

float X

The x coordinate of this T:Microsoft.Xna.Framework.Quaternion.

float Y

The y coordinate of this T:Microsoft.Xna.Framework.Quaternion.

float Z

The z coordinate of this T:Microsoft.Xna.Framework.Quaternion.

float W

The rotation component of this T:Microsoft.Xna.Framework.Quaternion.

readonly Quaternion Identity

Returns a quaternion representing no rotation.

string get_DebugDisplayString()

Quaternion Add(Quaternion quaternion1, Quaternion quaternion2)

Creates a new T:Microsoft.Xna.Framework.Quaternion that contains the sum of two quaternions.

Parameters:

• quaternion1 (Microsoft.Xna.Framework.Quaternion) – Source T:Microsoft.Xna.Framework.Quaternion.
• quaternion2 (Microsoft.Xna.Framework.Quaternion) – Source T:Microsoft.Xna.Framework.Quaternion.

Returns:

The result of the quaternion addition.

void Add(ref Quaternion quaternion1, ref Quaternion quaternion2, ref Quaternion result)

Parameters:

• (ref) quaternion1 (Microsoft.Xna.Framework.Quaternion) –
• (ref) quaternion2 (Microsoft.Xna.Framework.Quaternion) –
• (ref) result (Microsoft.Xna.Framework.Quaternion) –

Quaternion Concatenate(Quaternion value1, Quaternion value2)

Creates a new T:Microsoft.Xna.Framework.Quaternion that contains concatenation between two quaternion.

Parameters:

• value1 (Microsoft.Xna.Framework.Quaternion) – The first T:Microsoft.Xna.Framework.Quaternion to concatenate.
• value2 (Microsoft.Xna.Framework.Quaternion) – The second T:Microsoft.Xna.Framework.Quaternion to concatenate.

Returns:

The result of rotation of followed by rotation.

void Concatenate(ref Quaternion value1, ref Quaternion value2, ref Quaternion result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Quaternion) –
• (ref) value2 (Microsoft.Xna.Framework.Quaternion) –
• (ref) result (Microsoft.Xna.Framework.Quaternion) –

void Conjugate()

Transforms this quaternion into its conjugated version.

Quaternion Conjugate(Quaternion value)

Creates a new T:Microsoft.Xna.Framework.Quaternion that contains conjugated version of the specified quaternion.

Parameters:

• value (Microsoft.Xna.Framework.Quaternion) – The quaternion which values will be used to create the conjugated version.

Returns:

The conjugate version of the specified quaternion.

void Conjugate(ref Quaternion value, ref Quaternion result)

Parameters:

• (ref) value (Microsoft.Xna.Framework.Quaternion) –
• (ref) result (Microsoft.Xna.Framework.Quaternion) –

Quaternion CreateFromAxisAngle(Vector3 axis, float angle)

Creates a new T:Microsoft.Xna.Framework.Quaternion from the specified axis and angle.

Parameters:

• axis (Microsoft.Xna.Framework.Vector3) – The axis of rotation.
• angle (float) – The angle in radians.

Returns:

The new quaternion builded from axis and angle.

void CreateFromAxisAngle(ref Vector3 axis, float angle, ref Quaternion result)

Parameters:

• (ref) axis (Microsoft.Xna.Framework.Vector3) –
• angle (float) –
• (ref) result (Microsoft.Xna.Framework.Quaternion) –

Quaternion CreateFromRotationMatrix(Matrix matrix)

Creates a new T:Microsoft.Xna.Framework.Quaternion from the specified T:Microsoft.Xna.Framework.Matrix.

Parameters:

• matrix (Microsoft.Xna.Framework.Matrix) – The rotation matrix.

Returns:

A quaternion composed from the rotation part of the matrix.

void CreateFromRotationMatrix(ref Matrix matrix, ref Quaternion result)

Parameters:

• (ref) matrix (Microsoft.Xna.Framework.Matrix) –
• (ref) result (Microsoft.Xna.Framework.Quaternion) –

Quaternion CreateFromYawPitchRoll(float yaw, float pitch, float roll)

Creates a new T:Microsoft.Xna.Framework.Quaternion from the specified yaw, pitch and roll angles.

Parameters:

• yaw (float) – Yaw around the y axis in radians.
• pitch (float) – Pitch around the x axis in radians.
• roll (float) – Roll around the z axis in radians.

Returns:

A new quaternion from the concatenated yaw, pitch, and roll angles.

void CreateFromYawPitchRoll(float yaw, float pitch, float roll, ref Quaternion result)

Parameters:

• yaw (float) –
• pitch (float) –
• roll (float) –
• (ref) result (Microsoft.Xna.Framework.Quaternion) –

Quaternion Divide(Quaternion quaternion1, Quaternion quaternion2)

Divides a T:Microsoft.Xna.Framework.Quaternion by the other T:Microsoft.Xna.Framework.Quaternion.

Parameters:

• quaternion1 (Microsoft.Xna.Framework.Quaternion) – Source T:Microsoft.Xna.Framework.Quaternion.
• quaternion2 (Microsoft.Xna.Framework.Quaternion) – Divisor T:Microsoft.Xna.Framework.Quaternion.

Returns:

The result of dividing the quaternions.

void Divide(ref Quaternion quaternion1, ref Quaternion quaternion2, ref Quaternion result)

Parameters:

• (ref) quaternion1 (Microsoft.Xna.Framework.Quaternion) –
• (ref) quaternion2 (Microsoft.Xna.Framework.Quaternion) –
• (ref) result (Microsoft.Xna.Framework.Quaternion) –

float Dot(Quaternion quaternion1, Quaternion quaternion2)

Returns a dot product of two quaternions.

Parameters:

• quaternion1 (Microsoft.Xna.Framework.Quaternion) – The first quaternion.
• quaternion2 (Microsoft.Xna.Framework.Quaternion) – The second quaternion.

Returns:

The dot product of two quaternions.

void Dot(ref Quaternion quaternion1, ref Quaternion quaternion2, ref float result)

Parameters:

• (ref) quaternion1 (Microsoft.Xna.Framework.Quaternion) –
• (ref) quaternion2 (Microsoft.Xna.Framework.Quaternion) –
• (ref) result (float) –

bool Equals(System.Object obj)

Compares whether current instance is equal to specified T:System.Object.

Parameters:

• obj (System.Object) – The T:System.Object to compare.

Returns:

true if the instances are equal; false otherwise.

bool Equals(Quaternion other)

Compares whether current instance is equal to specified T:Microsoft.Xna.Framework.Quaternion.

Parameters:

• other (Microsoft.Xna.Framework.Quaternion) – The T:Microsoft.Xna.Framework.Quaternion to compare.

Returns:

true if the instances are equal; false otherwise.

int GetHashCode()

Gets the hash code of this T:Microsoft.Xna.Framework.Quaternion.

Returns:Hash code of this T:Microsoft.Xna.Framework.Quaternion.

Quaternion Inverse(Quaternion quaternion)

Returns the inverse quaternion which represents the opposite rotation.

Parameters:

• quaternion (Microsoft.Xna.Framework.Quaternion) – Source T:Microsoft.Xna.Framework.Quaternion.

Returns:

The inverse quaternion.

void Inverse(ref Quaternion quaternion, ref Quaternion result)

Parameters:

• (ref) quaternion (Microsoft.Xna.Framework.Quaternion) –
• (ref) result (Microsoft.Xna.Framework.Quaternion) –

float Length()

Returns the magnitude of the quaternion components.

Returns:The magnitude of the quaternion components.

float LengthSquared()

Returns the squared magnitude of the quaternion components.

Returns:The squared magnitude of the quaternion components.

Quaternion Lerp(Quaternion quaternion1, Quaternion quaternion2, float amount)

Performs a linear blend between two quaternions.

Parameters:

• quaternion1 (Microsoft.Xna.Framework.Quaternion) – Source T:Microsoft.Xna.Framework.Quaternion.
• quaternion2 (Microsoft.Xna.Framework.Quaternion) – Source T:Microsoft.Xna.Framework.Quaternion.
• amount (float) – The blend amount where 0 returns and 1 .

Returns:

The result of linear blending between two quaternions.

void Lerp(ref Quaternion quaternion1, ref Quaternion quaternion2, float amount, ref Quaternion result)

Parameters:

• (ref) quaternion1 (Microsoft.Xna.Framework.Quaternion) –
• (ref) quaternion2 (Microsoft.Xna.Framework.Quaternion) –
• amount (float) –
• (ref) result (Microsoft.Xna.Framework.Quaternion) –

Quaternion Slerp(Quaternion quaternion1, Quaternion quaternion2, float amount)

Performs a spherical linear blend between two quaternions.

Parameters:

• quaternion1 (Microsoft.Xna.Framework.Quaternion) – Source T:Microsoft.Xna.Framework.Quaternion.
• quaternion2 (Microsoft.Xna.Framework.Quaternion) – Source T:Microsoft.Xna.Framework.Quaternion.
• amount (float) – The blend amount where 0 returns and 1 .

Returns:

The result of spherical linear blending between two quaternions.

void Slerp(ref Quaternion quaternion1, ref Quaternion quaternion2, float amount, ref Quaternion result)

Parameters:

• (ref) quaternion1 (Microsoft.Xna.Framework.Quaternion) –
• (ref) quaternion2 (Microsoft.Xna.Framework.Quaternion) –
• amount (float) –
• (ref) result (Microsoft.Xna.Framework.Quaternion) –

Quaternion Subtract(Quaternion quaternion1, Quaternion quaternion2)

Creates a new T:Microsoft.Xna.Framework.Quaternion that contains subtraction of one T:Microsoft.Xna.Framework.Quaternion from another.

Parameters:

• quaternion1 (Microsoft.Xna.Framework.Quaternion) – Source T:Microsoft.Xna.Framework.Quaternion.
• quaternion2 (Microsoft.Xna.Framework.Quaternion) – Source T:Microsoft.Xna.Framework.Quaternion.

Returns:

The result of the quaternion subtraction.

void Subtract(ref Quaternion quaternion1, ref Quaternion quaternion2, ref Quaternion result)

Parameters:

• (ref) quaternion1 (Microsoft.Xna.Framework.Quaternion) –
• (ref) quaternion2 (Microsoft.Xna.Framework.Quaternion) –
• (ref) result (Microsoft.Xna.Framework.Quaternion) –

Quaternion Multiply(Quaternion quaternion1, Quaternion quaternion2)

Creates a new T:Microsoft.Xna.Framework.Quaternion that contains a multiplication of two quaternions.

Parameters:

• quaternion1 (Microsoft.Xna.Framework.Quaternion) – Source T:Microsoft.Xna.Framework.Quaternion.
• quaternion2 (Microsoft.Xna.Framework.Quaternion) – Source T:Microsoft.Xna.Framework.Quaternion.

Returns:

The result of the quaternion multiplication.

Quaternion Multiply(Quaternion quaternion1, float scaleFactor)

Creates a new T:Microsoft.Xna.Framework.Quaternion that contains a multiplication of T:Microsoft.Xna.Framework.Quaternion and a scalar.

Parameters:

• quaternion1 (Microsoft.Xna.Framework.Quaternion) – Source T:Microsoft.Xna.Framework.Quaternion.
• scaleFactor (float) – Scalar value.

Returns:

The result of the quaternion multiplication with a scalar.

void Multiply(ref Quaternion quaternion1, float scaleFactor, ref Quaternion result)

Parameters:

• (ref) quaternion1 (Microsoft.Xna.Framework.Quaternion) –
• scaleFactor (float) –
• (ref) result (Microsoft.Xna.Framework.Quaternion) –

void Multiply(ref Quaternion quaternion1, ref Quaternion quaternion2, ref Quaternion result)

Parameters:

• (ref) quaternion1 (Microsoft.Xna.Framework.Quaternion) –
• (ref) quaternion2 (Microsoft.Xna.Framework.Quaternion) –
• (ref) result (Microsoft.Xna.Framework.Quaternion) –

Quaternion Negate(Quaternion quaternion)

Flips the sign of the all the quaternion components.

Parameters:

• quaternion (Microsoft.Xna.Framework.Quaternion) – Source T:Microsoft.Xna.Framework.Quaternion.

Returns:

The result of the quaternion negation.

void Negate(ref Quaternion quaternion, ref Quaternion result)

Parameters:

• (ref) quaternion (Microsoft.Xna.Framework.Quaternion) –
• (ref) result (Microsoft.Xna.Framework.Quaternion) –

void Normalize()

Scales the quaternion magnitude to unit length.

Quaternion Normalize(Quaternion quaternion)

Scales the quaternion magnitude to unit length.

Parameters:

• quaternion (Microsoft.Xna.Framework.Quaternion) – Source T:Microsoft.Xna.Framework.Quaternion.

Returns:

The unit length quaternion.

void Normalize(ref Quaternion quaternion, ref Quaternion result)

Parameters:

• (ref) quaternion (Microsoft.Xna.Framework.Quaternion) –
• (ref) result (Microsoft.Xna.Framework.Quaternion) –

string ToString()

Returns a T:System.String representation of this T:Microsoft.Xna.Framework.Quaternion in the format: {X:[F:Microsoft.Xna.Framework.Quaternion.X] Y:[F:Microsoft.Xna.Framework.Quaternion.Y] Z:[F:Microsoft.Xna.Framework.Quaternion.Z] W:[F:Microsoft.Xna.Framework.Quaternion.W]}

Returns:A T:System.String representation of this T:Microsoft.Xna.Framework.Quaternion.

Vector4 ToVector4()

Gets a T:Microsoft.Xna.Framework.Vector4 representation for this object.

Returns:A T:Microsoft.Xna.Framework.Vector4 representation for this object.

Quaternion op_Addition(Quaternion quaternion1, Quaternion quaternion2)

Adds two quaternions.

Parameters:

• quaternion1 (Microsoft.Xna.Framework.Quaternion) – Source T:Microsoft.Xna.Framework.Quaternion on the left of the add sign.
• quaternion2 (Microsoft.Xna.Framework.Quaternion) – Source T:Microsoft.Xna.Framework.Quaternion on the right of the add sign.

Returns:

Sum of the vectors.

Quaternion op_Division(Quaternion quaternion1, Quaternion quaternion2)

Divides a T:Microsoft.Xna.Framework.Quaternion by the other T:Microsoft.Xna.Framework.Quaternion.

Parameters:

• quaternion1 (Microsoft.Xna.Framework.Quaternion) – Source T:Microsoft.Xna.Framework.Quaternion on the left of the div sign.
• quaternion2 (Microsoft.Xna.Framework.Quaternion) – Divisor T:Microsoft.Xna.Framework.Quaternion on the right of the div sign.

Returns:

The result of dividing the quaternions.

bool op_Equality(Quaternion quaternion1, Quaternion quaternion2)

Compares whether two T:Microsoft.Xna.Framework.Quaternion instances are equal.

Parameters:

• quaternion1 (Microsoft.Xna.Framework.Quaternion) – T:Microsoft.Xna.Framework.Quaternion instance on the left of the equal sign.
• quaternion2 (Microsoft.Xna.Framework.Quaternion) – T:Microsoft.Xna.Framework.Quaternion instance on the right of the equal sign.

Returns:

true if the instances are equal; false otherwise.

bool op_Inequality(Quaternion quaternion1, Quaternion quaternion2)

Compares whether two T:Microsoft.Xna.Framework.Quaternion instances are not equal.

Parameters:

• quaternion1 (Microsoft.Xna.Framework.Quaternion) – T:Microsoft.Xna.Framework.Quaternion instance on the left of the not equal sign.
• quaternion2 (Microsoft.Xna.Framework.Quaternion) – T:Microsoft.Xna.Framework.Quaternion instance on the right of the not equal sign.

Returns:

true if the instances are not equal; false otherwise.

Quaternion op_Multiply(Quaternion quaternion1, Quaternion quaternion2)

Multiplies two quaternions.

Parameters:

• quaternion1 (Microsoft.Xna.Framework.Quaternion) – Source T:Microsoft.Xna.Framework.Quaternion on the left of the mul sign.
• quaternion2 (Microsoft.Xna.Framework.Quaternion) – Source T:Microsoft.Xna.Framework.Quaternion on the right of the mul sign.

Returns:

Result of the quaternions multiplication.

Quaternion op_Multiply(Quaternion quaternion1, float scaleFactor)

Multiplies the components of quaternion by a scalar.

Parameters:

• quaternion1 (Microsoft.Xna.Framework.Quaternion) – Source T:Microsoft.Xna.Framework.Vector3 on the left of the mul sign.
• scaleFactor (float) – Scalar value on the right of the mul sign.

Returns:

Result of the quaternion multiplication with a scalar.

Quaternion op_Subtraction(Quaternion quaternion1, Quaternion quaternion2)

Subtracts a T:Microsoft.Xna.Framework.Quaternion from a T:Microsoft.Xna.Framework.Quaternion.

Parameters:

• quaternion1 (Microsoft.Xna.Framework.Quaternion) – Source T:Microsoft.Xna.Framework.Vector3 on the left of the sub sign.
• quaternion2 (Microsoft.Xna.Framework.Quaternion) – Source T:Microsoft.Xna.Framework.Vector3 on the right of the sub sign.

Returns:

Result of the quaternion subtraction.

Quaternion op_UnaryNegation(Quaternion quaternion)

Flips the sign of the all the quaternion components.

Parameters:

• quaternion (Microsoft.Xna.Framework.Quaternion) – Source T:Microsoft.Xna.Framework.Quaternion on the right of the sub sign.

Returns:

The result of the quaternion negation.

RasterizerState

class RasterizerState : GraphicsResource, System.IDisposable

RasterizerState CullClockwise

RasterizerState CullCounterClockwise

RasterizerState CullNone

CullMode CullMode

float DepthBias

FillMode FillMode

bool MultiSampleAntiAlias

bool ScissorTestEnable

float SlopeScaleDepthBias

bool DepthClipEnable

void BindToGraphicsDevice(GraphicsDevice device)

Parameters:

• device (Microsoft.Xna.Framework.Graphics.GraphicsDevice) –

void ThrowIfBound()

RasterizerState Clone()

void GraphicsDeviceResetting()

void PlatformApplyState(GraphicsDevice device)

Parameters:

• device (Microsoft.Xna.Framework.Graphics.GraphicsDevice) –

Ray

struct Ray : System.ValueType, System.IEquatable<Ray>

Vector3 Direction

Vector3 Position

bool Equals(System.Object obj)

Parameters:

• obj (System.Object) –

bool Equals(Ray other)

Parameters:

• other (Microsoft.Xna.Framework.Ray) –

int GetHashCode()

System.Nullable<Single> Intersects(BoundingBox box)

Parameters:

• box (Microsoft.Xna.Framework.BoundingBox) –

void Intersects(ref BoundingBox box, ref System.Nullable<Single> result)

Parameters:

• (ref) box (Microsoft.Xna.Framework.BoundingBox) –
• (ref) result (System.Nullable<Single>) –

System.Nullable<Single> Intersects(BoundingSphere sphere)

Parameters:

• sphere (Microsoft.Xna.Framework.BoundingSphere) –

System.Nullable<Single> Intersects(Plane plane)

Parameters:

• plane (Microsoft.Xna.Framework.Plane) –

void Intersects(ref Plane plane, ref System.Nullable<Single> result)

Parameters:

• (ref) plane (Microsoft.Xna.Framework.Plane) –
• (ref) result (System.Nullable<Single>) –

void Intersects(ref BoundingSphere sphere, ref System.Nullable<Single> result)

Parameters:

• (ref) sphere (Microsoft.Xna.Framework.BoundingSphere) –
• (ref) result (System.Nullable<Single>) –

bool op_Inequality(Ray a, Ray b)

Parameters:

• a (Microsoft.Xna.Framework.Ray) –
• b (Microsoft.Xna.Framework.Ray) –

bool op_Equality(Ray a, Ray b)

Parameters:

• a (Microsoft.Xna.Framework.Ray) –
• b (Microsoft.Xna.Framework.Ray) –

string get_DebugDisplayString()

string ToString()

Rectangle

struct Rectangle : System.ValueType, System.IEquatable<Rectangle>

Describes a 2D-rectangle.

int X

The x coordinate of the top-left corner of this T:Microsoft.Xna.Framework.Rectangle.

int Y

The y coordinate of the top-left corner of this T:Microsoft.Xna.Framework.Rectangle.

int Width

The width of this T:Microsoft.Xna.Framework.Rectangle.

int Height

The height of this T:Microsoft.Xna.Framework.Rectangle.

readonly Rectangle Empty

Returns a T:Microsoft.Xna.Framework.Rectangle with X=0, Y=0, Width=0, Height=0.

readonly int Left

Returns the x coordinate of the left edge of this T:Microsoft.Xna.Framework.Rectangle.

readonly int Right

Returns the x coordinate of the right edge of this T:Microsoft.Xna.Framework.Rectangle.

readonly int Top

Returns the y coordinate of the top edge of this T:Microsoft.Xna.Framework.Rectangle.

readonly int Bottom

Returns the y coordinate of the bottom edge of this T:Microsoft.Xna.Framework.Rectangle.

readonly bool IsEmpty

Whether or not this T:Microsoft.Xna.Framework.Rectangle has a F:Microsoft.Xna.Framework.Rectangle.Width and F:Microsoft.Xna.Framework.Rectangle.Height of 0, and a P:Microsoft.Xna.Framework.Rectangle.Location of (0, 0).

Point Location

The top-left coordinates of this T:Microsoft.Xna.Framework.Rectangle.

Point Size

The width-height coordinates of this T:Microsoft.Xna.Framework.Rectangle.

readonly Point Center

A T:Microsoft.Xna.Framework.Point located in the center of this T:Microsoft.Xna.Framework.Rectangle.

string get_DebugDisplayString()

bool op_Equality(Rectangle a, Rectangle b)

Compares whether two T:Microsoft.Xna.Framework.Rectangle instances are equal.

Parameters:

• a (Microsoft.Xna.Framework.Rectangle) – T:Microsoft.Xna.Framework.Rectangle instance on the left of the equal sign.
• b (Microsoft.Xna.Framework.Rectangle) – T:Microsoft.Xna.Framework.Rectangle instance on the right of the equal sign.

Returns:

true if the instances are equal; false otherwise.

bool op_Inequality(Rectangle a, Rectangle b)

Compares whether two T:Microsoft.Xna.Framework.Rectangle instances are not equal.

Parameters:

• a (Microsoft.Xna.Framework.Rectangle) – T:Microsoft.Xna.Framework.Rectangle instance on the left of the not equal sign.
• b (Microsoft.Xna.Framework.Rectangle) – T:Microsoft.Xna.Framework.Rectangle instance on the right of the not equal sign.

Returns:

true if the instances are not equal; false otherwise.

bool Contains(int x, int y)

Gets whether or not the provided coordinates lie within the bounds of this T:Microsoft.Xna.Framework.Rectangle.

Parameters:

• x (int) – The x coordinate of the point to check for containment.
• y (int) – The y coordinate of the point to check for containment.

Returns:

true if the provided coordinates lie inside this T:Microsoft.Xna.Framework.Rectangle; false otherwise.

bool Contains(float x, float y)

Gets whether or not the provided coordinates lie within the bounds of this T:Microsoft.Xna.Framework.Rectangle.

Parameters:

• x (float) – The x coordinate of the point to check for containment.
• y (float) – The y coordinate of the point to check for containment.

Returns:

true if the provided coordinates lie inside this T:Microsoft.Xna.Framework.Rectangle; false otherwise.

bool Contains(Point value)

Gets whether or not the provided T:Microsoft.Xna.Framework.Point lies within the bounds of this T:Microsoft.Xna.Framework.Rectangle.

Parameters:

• value (Microsoft.Xna.Framework.Point) – The coordinates to check for inclusion in this T:Microsoft.Xna.Framework.Rectangle.

Returns:

true if the provided T:Microsoft.Xna.Framework.Point lies inside this T:Microsoft.Xna.Framework.Rectangle; false otherwise.

void Contains(ref Point value, ref bool result)

Parameters:

• (ref) value (Microsoft.Xna.Framework.Point) –
• (ref) result (bool) –

bool Contains(Vector2 value)

Gets whether or not the provided T:Microsoft.Xna.Framework.Vector2 lies within the bounds of this T:Microsoft.Xna.Framework.Rectangle.

Parameters:

• value (Microsoft.Xna.Framework.Vector2) – The coordinates to check for inclusion in this T:Microsoft.Xna.Framework.Rectangle.

Returns:

true if the provided T:Microsoft.Xna.Framework.Vector2 lies inside this T:Microsoft.Xna.Framework.Rectangle; false otherwise.

void Contains(ref Vector2 value, ref bool result)

Parameters:

• (ref) value (Microsoft.Xna.Framework.Vector2) –
• (ref) result (bool) –

bool Contains(Rectangle value)

Gets whether or not the provided T:Microsoft.Xna.Framework.Rectangle lies within the bounds of this T:Microsoft.Xna.Framework.Rectangle.

Parameters:

• value (Microsoft.Xna.Framework.Rectangle) – The T:Microsoft.Xna.Framework.Rectangle to check for inclusion in this T:Microsoft.Xna.Framework.Rectangle.

Returns:

true if the provided T:Microsoft.Xna.Framework.Rectangle‘s bounds lie entirely inside this T:Microsoft.Xna.Framework.Rectangle; false otherwise.

void Contains(ref Rectangle value, ref bool result)

Parameters:

• (ref) value (Microsoft.Xna.Framework.Rectangle) –
• (ref) result (bool) –

bool Equals(System.Object obj)

Compares whether current instance is equal to specified T:System.Object.

Parameters:

• obj (System.Object) – The T:System.Object to compare.

Returns:

true if the instances are equal; false otherwise.

bool Equals(Rectangle other)

Compares whether current instance is equal to specified T:Microsoft.Xna.Framework.Rectangle.

Parameters:

• other (Microsoft.Xna.Framework.Rectangle) – The T:Microsoft.Xna.Framework.Rectangle to compare.

Returns:

true if the instances are equal; false otherwise.

int GetHashCode()

Gets the hash code of this T:Microsoft.Xna.Framework.Rectangle.

Returns:Hash code of this T:Microsoft.Xna.Framework.Rectangle.

void Inflate(int horizontalAmount, int verticalAmount)

Adjusts the edges of this T:Microsoft.Xna.Framework.Rectangle by specified horizontal and vertical amounts.

Parameters:

• horizontalAmount (int) – Value to adjust the left and right edges.
• verticalAmount (int) – Value to adjust the top and bottom edges.

void Inflate(float horizontalAmount, float verticalAmount)

Adjusts the edges of this T:Microsoft.Xna.Framework.Rectangle by specified horizontal and vertical amounts.

Parameters:

• horizontalAmount (float) – Value to adjust the left and right edges.
• verticalAmount (float) – Value to adjust the top and bottom edges.

bool Intersects(Rectangle value)

Gets whether or not the other T:Microsoft.Xna.Framework.Rectangle intersects with this rectangle.

Parameters:

• value (Microsoft.Xna.Framework.Rectangle) – The other rectangle for testing.

Returns:

true if other T:Microsoft.Xna.Framework.Rectangle intersects with this rectangle; false otherwise.

void Intersects(ref Rectangle value, ref bool result)

Parameters:

• (ref) value (Microsoft.Xna.Framework.Rectangle) –
• (ref) result (bool) –

Rectangle Intersect(Rectangle value1, Rectangle value2)

Creates a new T:Microsoft.Xna.Framework.Rectangle that contains overlapping region of two other rectangles.

Parameters:

• value1 (Microsoft.Xna.Framework.Rectangle) – The first T:Microsoft.Xna.Framework.Rectangle.
• value2 (Microsoft.Xna.Framework.Rectangle) – The second T:Microsoft.Xna.Framework.Rectangle.

Returns:

Overlapping region of the two rectangles.

void Intersect(ref Rectangle value1, ref Rectangle value2, ref Rectangle result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Rectangle) –
• (ref) value2 (Microsoft.Xna.Framework.Rectangle) –
• (ref) result (Microsoft.Xna.Framework.Rectangle) –

void Offset(int offsetX, int offsetY)

Changes the P:Microsoft.Xna.Framework.Rectangle.Location of this T:Microsoft.Xna.Framework.Rectangle.

Parameters:

• offsetX (int) – The x coordinate to add to this T:Microsoft.Xna.Framework.Rectangle.
• offsetY (int) – The y coordinate to add to this T:Microsoft.Xna.Framework.Rectangle.

void Offset(float offsetX, float offsetY)

Changes the P:Microsoft.Xna.Framework.Rectangle.Location of this T:Microsoft.Xna.Framework.Rectangle.

Parameters:

• offsetX (float) – The x coordinate to add to this T:Microsoft.Xna.Framework.Rectangle.
• offsetY (float) – The y coordinate to add to this T:Microsoft.Xna.Framework.Rectangle.

void Offset(Point amount)

Changes the P:Microsoft.Xna.Framework.Rectangle.Location of this T:Microsoft.Xna.Framework.Rectangle.

Parameters:

• amount (Microsoft.Xna.Framework.Point) – The x and y components to add to this T:Microsoft.Xna.Framework.Rectangle.

void Offset(Vector2 amount)

Changes the P:Microsoft.Xna.Framework.Rectangle.Location of this T:Microsoft.Xna.Framework.Rectangle.

Parameters:

• amount (Microsoft.Xna.Framework.Vector2) – The x and y components to add to this T:Microsoft.Xna.Framework.Rectangle.

string ToString()

Returns a T:System.String representation of this T:Microsoft.Xna.Framework.Rectangle in the format: {X:[F:Microsoft.Xna.Framework.Rectangle.X] Y:[F:Microsoft.Xna.Framework.Rectangle.Y] Width:[F:Microsoft.Xna.Framework.Rectangle.Width] Height:[F:Microsoft.Xna.Framework.Rectangle.Height]}

Returns:T:System.String representation of this T:Microsoft.Xna.Framework.Rectangle.

Rectangle Union(Rectangle value1, Rectangle value2)

Creates a new T:Microsoft.Xna.Framework.Rectangle that completely contains two other rectangles.

Parameters:

• value1 (Microsoft.Xna.Framework.Rectangle) – The first T:Microsoft.Xna.Framework.Rectangle.
• value2 (Microsoft.Xna.Framework.Rectangle) – The second T:Microsoft.Xna.Framework.Rectangle.

Returns:

The union of the two rectangles.

void Union(ref Rectangle value1, ref Rectangle value2, ref Rectangle result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Rectangle) –
• (ref) value2 (Microsoft.Xna.Framework.Rectangle) –
• (ref) result (Microsoft.Xna.Framework.Rectangle) –

RenderTarget2D

class RenderTarget2D : Texture2D, System.IDisposable, Microsoft.Xna.Framework.Graphics.IRenderTarget

readonly DepthFormat DepthStencilFormat

readonly int MultiSampleCount

readonly RenderTargetUsage RenderTargetUsage

readonly bool IsContentLost

public void add_ContentLost(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_ContentLost(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

void GraphicsDeviceResetting()

RenderTarget3D

class RenderTarget3D : Texture3D, System.IDisposable, Microsoft.Xna.Framework.Graphics.IRenderTarget

readonly DepthFormat DepthStencilFormat

readonly int MultiSampleCount

readonly RenderTargetUsage RenderTargetUsage

readonly bool IsContentLost

public void add_ContentLost(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_ContentLost(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

RenderTargetBinding

struct RenderTargetBinding : System.ValueType

readonly Texture RenderTarget

readonly int ArraySlice

DepthFormat get_DepthFormat()

RenderTargetBinding op_Implicit(RenderTarget2D renderTarget)

Parameters:

• renderTarget (Microsoft.Xna.Framework.Graphics.RenderTarget2D) –

RenderTargetBinding op_Implicit(RenderTarget3D renderTarget)

Parameters:

• renderTarget (Microsoft.Xna.Framework.Graphics.RenderTarget3D) –

RenderTargetCube

class RenderTargetCube : TextureCube, System.IDisposable, Microsoft.Xna.Framework.Graphics.IRenderTarget

Represents a texture cube that can be used as a render target.

readonly DepthFormat DepthStencilFormat

Gets the depth-stencil buffer format of this render target.

Value:The format of the depth-stencil buffer.

readonly int MultiSampleCount

Gets the number of multisample locations.

Value:The number of multisample locations.

readonly RenderTargetUsage RenderTargetUsage

Gets the usage mode of this render target.

Value:The usage mode of the render target.

readonly bool IsContentLost

public void add_ContentLost(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_ContentLost(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public SharpDX.Direct3D11.RenderTargetView GetRenderTargetView(int arraySlice)

Parameters:

• arraySlice (int) –

public SharpDX.Direct3D11.DepthStencilView GetDepthStencilView()

RenderTargetUsage

enum RenderTargetUsage : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines if the previous content in a render target is preserved when it set on the graphics device.

RenderTargetUsage DiscardContents

The render target content will not be preserved.

RenderTargetUsage PreserveContents

The render target content will be preserved even if it is slow or requires extra memory.

RenderTargetUsage PlatformContents

The render target content might be preserved if the platform can do so without a penalty in performance or memory usage.

ResourceContentManager

class ResourceContentManager : ContentManager, System.IDisposable

ResourceCreatedEventArgs

class ResourceCreatedEventArgs : System.EventArgs

readonly System.Object Resource

The newly created resource object.

void set_Resource(System.Object value)

Parameters:

• value (System.Object) –

ResourceDestroyedEventArgs

class ResourceDestroyedEventArgs : System.EventArgs

readonly string Name

The name of the destroyed resource.

readonly System.Object Tag

The resource manager tag of the destroyed resource.

void set_Name(string value)

Parameters:

• value (string) –

void set_Tag(System.Object value)

Parameters:

• value (System.Object) –

Rg32

struct Rg32 : System.ValueType, Microsoft.Xna.Framework.Graphics.PackedVector.IPackedVector<UInt32>, IPackedVector, System.IEquatable<Rg32>

Packed vector type containing two 16-bit unsigned normalized values ranging from 0 to 1.

uint PackedValue

Gets and sets the packed value.

Vector2 ToVector2()

Gets the packed vector in Vector2 format.

Returns:The packed vector in Vector2 format

bool Equals(System.Object obj)

Compares an object with the packed vector.

Parameters:

• obj (System.Object) – The object to compare.

Returns:

True if the object is equal to the packed vector.

bool Equals(Rg32 other)

Compares another Rg32 packed vector with the packed vector.

Parameters:

• other (Microsoft.Xna.Framework.Graphics.PackedVector.Rg32) – The Rg32 packed vector to compare.

Returns:

True if the packed vectors are equal.

string ToString()

Gets a string representation of the packed vector.

Returns:A string representation of the packed vector.

int GetHashCode()

Gets a hash code of the packed vector.

Returns:The hash code for the packed vector.

bool op_Equality(Rg32 lhs, Rg32 rhs)

Parameters:

• lhs (Microsoft.Xna.Framework.Graphics.PackedVector.Rg32) –
• rhs (Microsoft.Xna.Framework.Graphics.PackedVector.Rg32) –

bool op_Inequality(Rg32 lhs, Rg32 rhs)

Parameters:

• lhs (Microsoft.Xna.Framework.Graphics.PackedVector.Rg32) –
• rhs (Microsoft.Xna.Framework.Graphics.PackedVector.Rg32) –

Rgba1010102

struct Rgba1010102 : System.ValueType, Microsoft.Xna.Framework.Graphics.PackedVector.IPackedVector<UInt32>, IPackedVector, System.IEquatable<Rgba1010102>

Packed vector type containing unsigned normalized values ranging from 0 to 1. The x, y and z components use 10 bits, and the w component uses 2 bits.

uint PackedValue

Gets and sets the packed value.

Vector4 ToVector4()

Gets the packed vector in Vector4 format.

Returns:The packed vector in Vector4 format

bool Equals(System.Object obj)

Compares an object with the packed vector.

Parameters:

• obj (System.Object) – The object to compare.

Returns:

True if the object is equal to the packed vector.

bool Equals(Rgba1010102 other)

Compares another Rgba1010102 packed vector with the packed vector.

Parameters:

• other (Microsoft.Xna.Framework.Graphics.PackedVector.Rgba1010102) – The Rgba1010102 packed vector to compare.

Returns:

True if the packed vectors are equal.

string ToString()

Gets a string representation of the packed vector.

Returns:A string representation of the packed vector.

int GetHashCode()

Gets a hash code of the packed vector.

Returns:The hash code for the packed vector.

bool op_Equality(Rgba1010102 lhs, Rgba1010102 rhs)

Parameters:

• lhs (Microsoft.Xna.Framework.Graphics.PackedVector.Rgba1010102) –
• rhs (Microsoft.Xna.Framework.Graphics.PackedVector.Rgba1010102) –

bool op_Inequality(Rgba1010102 lhs, Rgba1010102 rhs)

Parameters:

• lhs (Microsoft.Xna.Framework.Graphics.PackedVector.Rgba1010102) –
• rhs (Microsoft.Xna.Framework.Graphics.PackedVector.Rgba1010102) –

Rgba64

struct Rgba64 : System.ValueType, Microsoft.Xna.Framework.Graphics.PackedVector.IPackedVector<UInt64>, IPackedVector, System.IEquatable<Rgba64>

Packed vector type containing four 16-bit unsigned normalized values ranging from 0 to 1.

ulong PackedValue

Gets and sets the packed value.

Vector4 ToVector4()

Gets the packed vector in Vector4 format.

Returns:The packed vector in Vector4 format

bool Equals(System.Object obj)

Compares an object with the packed vector.

Parameters:

• obj (System.Object) – The object to compare.

Returns:

True if the object is equal to the packed vector.

bool Equals(Rgba64 other)

Compares another Rgba64 packed vector with the packed vector.

Parameters:

• other (Microsoft.Xna.Framework.Graphics.PackedVector.Rgba64) – The Rgba64 packed vector to compare.

Returns:

True if the packed vectors are equal.

string ToString()

Gets a string representation of the packed vector.

Returns:A string representation of the packed vector.

int GetHashCode()

Gets a hash code of the packed vector.

Returns:The hash code for the packed vector.

bool op_Equality(Rgba64 lhs, Rgba64 rhs)

Parameters:

• lhs (Microsoft.Xna.Framework.Graphics.PackedVector.Rgba64) –
• rhs (Microsoft.Xna.Framework.Graphics.PackedVector.Rgba64) –

bool op_Inequality(Rgba64 lhs, Rgba64 rhs)

Parameters:

• lhs (Microsoft.Xna.Framework.Graphics.PackedVector.Rgba64) –
• rhs (Microsoft.Xna.Framework.Graphics.PackedVector.Rgba64) –

SamplerState

class SamplerState : GraphicsResource, System.IDisposable

SamplerState AnisotropicClamp

SamplerState AnisotropicWrap

SamplerState LinearClamp

SamplerState LinearWrap

SamplerState PointClamp

SamplerState PointWrap

TextureAddressMode AddressU

TextureAddressMode AddressV

TextureAddressMode AddressW

Color BorderColor

TextureFilter Filter

int MaxAnisotropy

int MaxMipLevel

float MipMapLevelOfDetailBias

CompareFunction ComparisonFunction

When using comparison sampling, also set P:Microsoft.Xna.Framework.Graphics.SamplerState.FilterMode to F:Microsoft.Xna.Framework.Graphics.TextureFilterMode.Comparison.

TextureFilterMode FilterMode

void BindToGraphicsDevice(GraphicsDevice device)

Parameters:

• device (Microsoft.Xna.Framework.Graphics.GraphicsDevice) –

void ThrowIfBound()

SamplerState Clone()

void GraphicsDeviceResetting()

SharpDX.Direct3D11.SamplerState GetState(GraphicsDevice device)

Parameters:

• device (Microsoft.Xna.Framework.Graphics.GraphicsDevice) –

SamplerStateCollection

class SamplerStateCollection : System.Object

SamplerState Item

void Clear()

void Dirty()

Mark all the sampler slots as dirty.

void PlatformSetSamplers(GraphicsDevice device)

Parameters:

• device (Microsoft.Xna.Framework.Graphics.GraphicsDevice) –

SamplerType

enum SamplerType : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

SamplerType Sampler2D

SamplerType SamplerCube

SamplerType SamplerVolume

SamplerType Sampler1D

SetDataOptions

enum SetDataOptions : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines how vertex or index buffer data will be flushed during a SetData operation.

SetDataOptions None

The SetData can overwrite the portions of existing data.

SetDataOptions Discard

The SetData will discard the entire buffer. A pointer to a new memory area is returned and rendering from the previous area do not stall.

SetDataOptions NoOverwrite

The SetData operation will not overwrite existing data. This allows the driver to return immediately from a SetData operation and continue rendering.

ShaderStage

enum ShaderStage : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

ShaderStage Vertex

ShaderStage Pixel

Short2

struct Short2 : System.ValueType, Microsoft.Xna.Framework.Graphics.PackedVector.IPackedVector<UInt32>, IPackedVector, System.IEquatable<Short2>

uint PackedValue

bool op_Inequality(Short2 a, Short2 b)

Parameters:

• a (Microsoft.Xna.Framework.Graphics.PackedVector.Short2) –
• b (Microsoft.Xna.Framework.Graphics.PackedVector.Short2) –

bool op_Equality(Short2 a, Short2 b)

Parameters:

• a (Microsoft.Xna.Framework.Graphics.PackedVector.Short2) –
• b (Microsoft.Xna.Framework.Graphics.PackedVector.Short2) –

bool Equals(System.Object obj)

Parameters:

• obj (System.Object) –

bool Equals(Short2 other)

Parameters:

• other (Microsoft.Xna.Framework.Graphics.PackedVector.Short2) –

int GetHashCode()

string ToString()

Vector2 ToVector2()

Short4

struct Short4 : System.ValueType, Microsoft.Xna.Framework.Graphics.PackedVector.IPackedVector<UInt64>, IPackedVector, System.IEquatable<Short4>

Packed vector type containing four 16-bit signed integer values.

ulong PackedValue

Directly gets or sets the packed representation of the value.

Value:The packed representation of the value.

bool op_Inequality(Short4 a, Short4 b)

Compares the current instance of a class to another instance to determine whether they are different.

Parameters:

• a (Microsoft.Xna.Framework.Graphics.PackedVector.Short4) – The object to the left of the equality operator.
• b (Microsoft.Xna.Framework.Graphics.PackedVector.Short4) – The object to the right of the equality operator.

Returns:

true if the objects are different; false otherwise.

bool op_Equality(Short4 a, Short4 b)

Compares the current instance of a class to another instance to determine whether they are the same.

Parameters:

• a (Microsoft.Xna.Framework.Graphics.PackedVector.Short4) – The object to the left of the equality operator.
• b (Microsoft.Xna.Framework.Graphics.PackedVector.Short4) – The object to the right of the equality operator.

Returns:

true if the objects are the same; false otherwise.

bool Equals(System.Object obj)

Returns a value that indicates whether the current instance is equal to a specified object.

Parameters:

• obj (System.Object) – The object with which to make the comparison.

Returns:

true if the current instance is equal to the specified object; false otherwise.

bool Equals(Short4 other)

Returns a value that indicates whether the current instance is equal to a specified object.

Parameters:

• other (Microsoft.Xna.Framework.Graphics.PackedVector.Short4) – The object with which to make the comparison.

Returns:

true if the current instance is equal to the specified object; false otherwise.

int GetHashCode()

Gets the hash code for the current instance.

Returns:Hash code for the instance.

string ToString()

Returns a string representation of the current instance.

Returns:String that represents the object.

Vector4 ToVector4()

Expands the packed representation into a Vector4.

Returns:The expanded vector.

SkinnedEffect

class SkinnedEffect : Effect, System.IDisposable, IEffectMatrices, IEffectLights, IEffectFog

Built-in effect for rendering skinned character models.

int MaxBones

Matrix World

Gets or sets the world matrix.

Matrix View

Gets or sets the view matrix.

Matrix Projection

Gets or sets the projection matrix.

Vector3 DiffuseColor

Gets or sets the material diffuse color (range 0 to 1).

Vector3 EmissiveColor

Gets or sets the material emissive color (range 0 to 1).

Vector3 SpecularColor

Gets or sets the material specular color (range 0 to 1).

float SpecularPower

Gets or sets the material specular power.

float Alpha

Gets or sets the material alpha.

bool PreferPerPixelLighting

Gets or sets the per-pixel lighting prefer flag.

Vector3 AmbientLightColor

Gets or sets the ambient light color (range 0 to 1).

readonly DirectionalLight DirectionalLight0

Gets the first directional light.

readonly DirectionalLight DirectionalLight1

Gets the second directional light.

readonly DirectionalLight DirectionalLight2

Gets the third directional light.

bool FogEnabled

Gets or sets the fog enable flag.

float FogStart

Gets or sets the fog start distance.

float FogEnd

Gets or sets the fog end distance.

Vector3 FogColor

Gets or sets the fog color.

Texture2D Texture

Gets or sets the current texture.

int WeightsPerVertex

Gets or sets the number of skinning weights to evaluate for each vertex (1, 2, or 4).

public void SetBoneTransforms(Microsoft.Xna.Framework.Matrix[] boneTransforms)

Sets an array of skinning bone transform matrices.

Parameters:

• boneTransforms (Microsoft.Xna.Framework.Matrix[]) –

public Microsoft.Xna.Framework.Matrix[] GetBoneTransforms(int count)

Gets a copy of the current skinning bone transform matrices.

Parameters:

• count (int) –

public Effect Clone()

Creates a clone of the current SkinnedEffect instance.

public void EnableDefaultLighting()

Sets up the standard key/fill/back lighting rig.

void OnApply()

Lazily computes derived parameter values immediately before applying the effect.

Song

class Song : System.Object, System.IEquatable<Song>, System.IDisposable

readonly Album Album

Gets the Album on which the Song appears.

readonly Artist Artist

Gets the Artist of the Song.

readonly Genre Genre

Gets the Genre of the Song.

readonly bool IsDisposed

readonly System.TimeSpan Duration

readonly bool IsProtected

readonly bool IsRated

readonly string Name

readonly int PlayCount

readonly int Rating

readonly int TrackNumber

string get_FilePath()

public Song FromUri(string name, System.Uri uri)

Parameters:

• name (string) –
• uri (System.Uri) –

public void Dispose()

public int GetHashCode()

public bool Equals(Song song)

Parameters:

• song (Microsoft.Xna.Framework.Media.Song) –

public bool Equals(System.Object obj)

Parameters:

• obj (System.Object) –

public bool op_Equality(Song song1, Song song2)

Parameters:

• song1 (Microsoft.Xna.Framework.Media.Song) –
• song2 (Microsoft.Xna.Framework.Media.Song) –

public bool op_Inequality(Song song1, Song song2)

Parameters:

• song1 (Microsoft.Xna.Framework.Media.Song) –
• song2 (Microsoft.Xna.Framework.Media.Song) –

SharpDX.MediaFoundation.Topology get_Topology()

SongCollection

class SongCollection : System.Object, System.Collections.Generic.ICollection<Song>, System.Collections.Generic.IEnumerable<Song>, System.Collections.IEnumerable, System.IDisposable

readonly int Count

readonly bool IsReadOnly

readonly Song Item

public void Dispose()

public System.Collections.Generic.IEnumerator<Song> GetEnumerator()

public void Add(Song item)

Parameters:

• item (Microsoft.Xna.Framework.Media.Song) –

public void Clear()

public SongCollection Clone()

public bool Contains(Song item)

Parameters:

• item (Microsoft.Xna.Framework.Media.Song) –

public void CopyTo(Microsoft.Xna.Framework.Media.Song[] array, int arrayIndex)

Parameters:

• array (Microsoft.Xna.Framework.Media.Song[]) –
• arrayIndex (int) –

public int IndexOf(Song item)

Parameters:

• item (Microsoft.Xna.Framework.Media.Song) –

public bool Remove(Song item)

Parameters:

• item (Microsoft.Xna.Framework.Media.Song) –

SoundBank

class SoundBank : System.Object, System.IDisposable

Represents a collection of Cues.

readonly bool IsInUse

Is true if the SoundBank has any live Cues in use.

readonly bool IsDisposed

Is true if the SoundBank has been disposed.

SoundEffectInstance GetSoundEffectInstance(int waveBankIndex, int trackIndex)

Parameters:

• waveBankIndex (int) –
• trackIndex (int) –

public Cue GetCue(string name)

Returns a pooled Cue object.

Parameters:

• name (string) – Friendly name of the cue to get.

Returns:

a unique Cue object from a pool.

public void PlayCue(string name)

Plays a cue.

Parameters:

• name (string) – Name of the cue to play.

public void PlayCue(string name, AudioListener listener, AudioEmitter emitter)

Plays a cue with static 3D positional information.

Parameters:

• name (string) – The name of the cue to play.
• listener (Microsoft.Xna.Framework.Audio.AudioListener) – The listener state.
• emitter (Microsoft.Xna.Framework.Audio.AudioEmitter) – The cue emitter state.

public void add_Disposing(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_Disposing(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void Dispose()

Disposes the SoundBank.

SoundEffect

class SoundEffect : System.Object, System.IDisposable

Represents a loaded sound resource.

readonly System.TimeSpan Duration

Gets the duration of the SoundEffect.

string Name

Gets or sets the asset name of the SoundEffect.

float MasterVolume

Gets or sets the master volume scale applied to all SoundEffectInstances.

float DistanceScale

Gets or sets the scale of distance calculations.

float DopplerScale

Gets or sets the scale of Doppler calculations applied to sounds.

float SpeedOfSound

Returns the speed of sound used when calculating the Doppler effect..

readonly bool IsDisposed

Indicates whether the object is disposed.

SharpDX.Multimedia.Speakers Speakers

public SoundEffectInstance CreateInstance()

Creates a new SoundEffectInstance for this SoundEffect.

Returns:A new SoundEffectInstance for this SoundEffect.

public SoundEffect FromStream(System.IO.Stream stream)

Creates a new SoundEffect object based on the specified data stream.

Parameters:

• stream (System.IO.Stream) – A stream containing the PCM wave data.

Returns:

A new SoundEffect object.

public System.TimeSpan GetSampleDuration(int sizeInBytes, int sampleRate, AudioChannels channels)

Returns the duration for 16bit PCM audio.

Parameters:

• sizeInBytes (int) – The length of the audio data in bytes.
• sampleRate (int) – Sample rate, in Hertz (Hz). Must be between 8000 Hz and 48000 Hz
• channels (Microsoft.Xna.Framework.Audio.AudioChannels) – Number of channels in the audio data.

Returns:

The duration of the audio data.

public int GetSampleSizeInBytes(System.TimeSpan duration, int sampleRate, AudioChannels channels)

Returns the data size in bytes for 16bit PCM audio.

Parameters:

• duration (System.TimeSpan) – The total duration of the audio data.
• sampleRate (int) – Sample rate, in Hertz (Hz), of audio data. Must be between 8,000 and 48,000 Hz.
• channels (Microsoft.Xna.Framework.Audio.AudioChannels) – Number of channels in the audio data.

Returns:

The size in bytes of a single sample of audio data.

public bool Play()

Gets an internal SoundEffectInstance and plays it.

Returns:True if a SoundEffectInstance was successfully played, false if not.

public bool Play(float volume, float pitch, float pan)

Gets an internal SoundEffectInstance and plays it with the specified volume, pitch, and panning.

Parameters:

• volume (float) – Volume, ranging from 0.0 (silence) to 1.0 (full volume). Volume during playback is scaled by SoundEffect.MasterVolume.
• pitch (float) – Pitch adjustment, ranging from -1.0 (down an octave) to 0.0 (no change) to 1.0 (up an octave).
• pan (float) – Panning, ranging from -1.0 (left speaker) to 0.0 (centered), 1.0 (right speaker).

Returns:

True if a SoundEffectInstance was successfully created and played, false if not.

SoundEffectInstance GetPooledInstance(bool forXAct)

Returns a sound effect instance from the pool or null if none are available.

Parameters:

• forXAct (bool) –

public void Dispose()

Releases the resources held by this T:Microsoft.Xna.Framework.Audio.SoundEffect.

SharpDX.XAudio2.XAudio2 get_Device()

SharpDX.XAudio2.MasteringVoice get_MasterVoice()

SharpDX.X3DAudio.X3DAudio get_Device3D()

SharpDX.XAudio2.SubmixVoice get_ReverbVoice()

void InitializeSoundEffect()

Initializes XAudio.

void PlatformSetReverbSettings(Microsoft.Xna.Framework.Audio.ReverbSettings reverbSettings)

Parameters:

• reverbSettings (Microsoft.Xna.Framework.Audio.ReverbSettings) –

void PlatformShutdown()

SoundEffectInstance

class SoundEffectInstance : System.Object, System.IDisposable

Represents a single instance of a playing, paused, or stopped sound.

bool IsLooped

Enables or Disables whether the SoundEffectInstance should repeat after playback.

float Pan

Gets or sets the pan, or speaker balance..

Value:Pan value ranging from -1.0 (left speaker) to 0.0 (centered), 1.0 (right speaker). Values outside of this range will throw an exception.

float Pitch

Gets or sets the pitch adjustment.

Value:Pitch adjustment, ranging from -1.0 (down an octave) to 0.0 (no change) to 1.0 (up an octave). Values outside of this range will throw an Exception.

float Volume

Gets or sets the volume of the SoundEffectInstance.

Value:Volume, ranging from 0.0 (silence) to 1.0 (full volume). Volume during playback is scaled by SoundEffect.MasterVolume.

readonly SoundState State

Gets the SoundEffectInstance’s current playback state.

readonly bool IsDisposed

Indicates whether the object is disposed.

public void Apply3D(AudioListener listener, AudioEmitter emitter)

Applies 3D positioning to the SoundEffectInstance using a single listener.

Parameters:

• listener (Microsoft.Xna.Framework.Audio.AudioListener) – Data about the listener.
• emitter (Microsoft.Xna.Framework.Audio.AudioEmitter) – Data about the source of emission.

public void Apply3D(Microsoft.Xna.Framework.Audio.AudioListener[] listeners, AudioEmitter emitter)

Applies 3D positioning to the SoundEffectInstance using multiple listeners.

Parameters:

• listeners (Microsoft.Xna.Framework.Audio.AudioListener[]) – Data about each listener.
• emitter (Microsoft.Xna.Framework.Audio.AudioEmitter) – Data about the source of emission.

public void Pause()

Pauses playback of a SoundEffectInstance.

public void Play()

Plays or resumes a SoundEffectInstance.

public void Resume()

Resumes playback for a SoundEffectInstance.

public void Stop()

Immediately stops playing a SoundEffectInstance.

public void Stop(bool immediate)

Stops playing a SoundEffectInstance, either immediately or as authored.

Parameters:

• immediate (bool) – Determined whether the sound stops immediately, or after playing its release phase and/or transitions.

public void Dispose()

Releases the resources held by this T:Microsoft.Xna.Framework.Audio.SoundEffectInstance.

void UpdateOutputMatrix()

System.Single[] CalculateOutputMatrix(float pan, float scale, int inputChannels)

Parameters:

• pan (float) –
• scale (float) –
• inputChannels (int) –

void PlatformSetReverbMix(float mix)

Parameters:

• mix (float) –

void PlatformSetFilter(Microsoft.Xna.Framework.Audio.FilterMode mode, float filterQ, float frequency)

Parameters:

• mode (Microsoft.Xna.Framework.Audio.FilterMode) –
• filterQ (float) –
• frequency (float) –

void PlatformClearFilter()

SoundState

enum SoundState : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Described the playback state of a SoundEffectInstance.

SoundState Playing

The SoundEffectInstance is currently playing.

SoundState Paused

The SoundEffectInstance is currently paused.

SoundState Stopped

The SoundEffectInstance is currently stopped.

SpriteBatch

class SpriteBatch : GraphicsResource, System.IDisposable

Helper class for drawing text strings and sprites in one or more optimized batches.

public void Begin(SpriteSortMode sortMode, BlendState blendState, SamplerState samplerState, DepthStencilState depthStencilState, RasterizerState rasterizerState, Effect effect, System.Nullable<Matrix> transformMatrix)

Begins a new sprite and text batch with the specified render state.

Parameters:

• sortMode (Microsoft.Xna.Framework.Graphics.SpriteSortMode) – The drawing order for sprite and text drawing. F:Microsoft.Xna.Framework.Graphics.SpriteSortMode.Deferred by default.
• blendState (Microsoft.Xna.Framework.Graphics.BlendState) – State of the blending. Uses F:Microsoft.Xna.Framework.Graphics.BlendState.AlphaBlend if null.
• samplerState (Microsoft.Xna.Framework.Graphics.SamplerState) – State of the sampler. Uses F:Microsoft.Xna.Framework.Graphics.SamplerState.LinearClamp if null.
• depthStencilState (Microsoft.Xna.Framework.Graphics.DepthStencilState) – State of the depth-stencil buffer. Uses F:Microsoft.Xna.Framework.Graphics.DepthStencilState.None if null.
• rasterizerState (Microsoft.Xna.Framework.Graphics.RasterizerState) – State of the rasterization. Uses F:Microsoft.Xna.Framework.Graphics.RasterizerState.CullCounterClockwise if null.
• effect (Microsoft.Xna.Framework.Graphics.Effect) – A custom T:Microsoft.Xna.Framework.Graphics.Effect to override the default sprite effect. Uses default sprite effect if null.
• transformMatrix (System.Nullable<Matrix>) – An optional matrix used to transform the sprite geometry. Uses P:Microsoft.Xna.Framework.Matrix.Identity if null.

public void End()

Flushes all batched text and sprites to the screen.

public void Draw(Texture2D texture, System.Nullable<Vector2> position, System.Nullable<Rectangle> destinationRectangle, System.Nullable<Rectangle> sourceRectangle, System.Nullable<Vector2> origin, float rotation, System.Nullable<Vector2> scale, System.Nullable<Color> color, SpriteEffects effects, float layerDepth)

Submit a sprite for drawing in the current batch.

Parameters:

• texture (Microsoft.Xna.Framework.Graphics.Texture2D) – A texture.
• position (System.Nullable<Vector2>) – The drawing location on screen or null if is used.
• destinationRectangle (System.Nullable<Rectangle>) – The drawing bounds on screen or null if is used.
• sourceRectangle (System.Nullable<Rectangle>) – An optional region on the texture which will be rendered. If null - draws full texture.
• origin (System.Nullable<Vector2>) – An optional center of rotation. Uses P:Microsoft.Xna.Framework.Vector2.Zero if null.
• rotation (float) – An optional rotation of this sprite. 0 by default.
• scale (System.Nullable<Vector2>) – An optional scale vector. Uses P:Microsoft.Xna.Framework.Vector2.One if null.
• color (System.Nullable<Color>) – An optional color mask. Uses P:Microsoft.Xna.Framework.Color.White if null.
• effects (Microsoft.Xna.Framework.Graphics.SpriteEffects) – The optional drawing modificators. F:Microsoft.Xna.Framework.Graphics.SpriteEffects.None by default.
• layerDepth (float) – An optional depth of the layer of this sprite. 0 by default.

public void Draw(Texture2D texture, Vector2 position, System.Nullable<Rectangle> sourceRectangle, Color color, float rotation, Vector2 origin, Vector2 scale, SpriteEffects effects, float layerDepth)

Submit a sprite for drawing in the current batch.

Parameters:

• texture (Microsoft.Xna.Framework.Graphics.Texture2D) – A texture.
• position (Microsoft.Xna.Framework.Vector2) – The drawing location on screen.
• sourceRectangle (System.Nullable<Rectangle>) – An optional region on the texture which will be rendered. If null - draws full texture.
• color (Microsoft.Xna.Framework.Color) – A color mask.
• rotation (float) – A rotation of this sprite.
• origin (Microsoft.Xna.Framework.Vector2) – Center of the rotation. 0,0 by default.
• scale (Microsoft.Xna.Framework.Vector2) – A scaling of this sprite.
• effects (Microsoft.Xna.Framework.Graphics.SpriteEffects) – Modificators for drawing. Can be combined.
• layerDepth (float) – A depth of the layer of this sprite.

public void Draw(Texture2D texture, Vector2 position, System.Nullable<Rectangle> sourceRectangle, Color color, float rotation, Vector2 origin, float scale, SpriteEffects effects, float layerDepth)

Submit a sprite for drawing in the current batch.

Parameters:

• texture (Microsoft.Xna.Framework.Graphics.Texture2D) – A texture.
• position (Microsoft.Xna.Framework.Vector2) – The drawing location on screen.
• sourceRectangle (System.Nullable<Rectangle>) – An optional region on the texture which will be rendered. If null - draws full texture.
• color (Microsoft.Xna.Framework.Color) – A color mask.
• rotation (float) – A rotation of this sprite.
• origin (Microsoft.Xna.Framework.Vector2) – Center of the rotation. 0,0 by default.
• scale (float) – A scaling of this sprite.
• effects (Microsoft.Xna.Framework.Graphics.SpriteEffects) – Modificators for drawing. Can be combined.
• layerDepth (float) – A depth of the layer of this sprite.

public void Draw(Texture2D texture, Rectangle destinationRectangle, System.Nullable<Rectangle> sourceRectangle, Color color, float rotation, Vector2 origin, SpriteEffects effects, float layerDepth)

Submit a sprite for drawing in the current batch.

Parameters:

• texture (Microsoft.Xna.Framework.Graphics.Texture2D) – A texture.
• destinationRectangle (Microsoft.Xna.Framework.Rectangle) – The drawing bounds on screen.
• sourceRectangle (System.Nullable<Rectangle>) – An optional region on the texture which will be rendered. If null - draws full texture.
• color (Microsoft.Xna.Framework.Color) – A color mask.
• rotation (float) – A rotation of this sprite.
• origin (Microsoft.Xna.Framework.Vector2) – Center of the rotation. 0,0 by default.
• effects (Microsoft.Xna.Framework.Graphics.SpriteEffects) – Modificators for drawing. Can be combined.
• layerDepth (float) – A depth of the layer of this sprite.

void FlushIfNeeded()

public void Draw(Texture2D texture, Vector2 position, System.Nullable<Rectangle> sourceRectangle, Color color)

Submit a sprite for drawing in the current batch.

Parameters:

• texture (Microsoft.Xna.Framework.Graphics.Texture2D) – A texture.
• position (Microsoft.Xna.Framework.Vector2) – The drawing location on screen.
• sourceRectangle (System.Nullable<Rectangle>) – An optional region on the texture which will be rendered. If null - draws full texture.
• color (Microsoft.Xna.Framework.Color) – A color mask.

public void Draw(Texture2D texture, Rectangle destinationRectangle, System.Nullable<Rectangle> sourceRectangle, Color color)

Submit a sprite for drawing in the current batch.

Parameters:

• texture (Microsoft.Xna.Framework.Graphics.Texture2D) – A texture.
• destinationRectangle (Microsoft.Xna.Framework.Rectangle) – The drawing bounds on screen.
• sourceRectangle (System.Nullable<Rectangle>) – An optional region on the texture which will be rendered. If null - draws full texture.
• color (Microsoft.Xna.Framework.Color) – A color mask.

public void Draw(Texture2D texture, Vector2 position, Color color)

Submit a sprite for drawing in the current batch.

Parameters:

• texture (Microsoft.Xna.Framework.Graphics.Texture2D) – A texture.
• position (Microsoft.Xna.Framework.Vector2) – The drawing location on screen.
• color (Microsoft.Xna.Framework.Color) – A color mask.

public void Draw(Texture2D texture, Rectangle destinationRectangle, Color color)

Submit a sprite for drawing in the current batch.

Parameters:

• texture (Microsoft.Xna.Framework.Graphics.Texture2D) – A texture.
• destinationRectangle (Microsoft.Xna.Framework.Rectangle) – The drawing bounds on screen.
• color (Microsoft.Xna.Framework.Color) – A color mask.

public void DrawString(SpriteFont spriteFont, string text, Vector2 position, Color color)

Submit a text string of sprites for drawing in the current batch.

Parameters:

• spriteFont (Microsoft.Xna.Framework.Graphics.SpriteFont) – A font.
• text (string) – The text which will be drawn.
• position (Microsoft.Xna.Framework.Vector2) – The drawing location on screen.
• color (Microsoft.Xna.Framework.Color) – A color mask.

public void DrawString(SpriteFont spriteFont, string text, Vector2 position, Color color, float rotation, Vector2 origin, float scale, SpriteEffects effects, float layerDepth)

Submit a text string of sprites for drawing in the current batch.

Parameters:

• spriteFont (Microsoft.Xna.Framework.Graphics.SpriteFont) – A font.
• text (string) – The text which will be drawn.
• position (Microsoft.Xna.Framework.Vector2) – The drawing location on screen.
• color (Microsoft.Xna.Framework.Color) – A color mask.
• rotation (float) – A rotation of this string.
• origin (Microsoft.Xna.Framework.Vector2) – Center of the rotation. 0,0 by default.
• scale (float) – A scaling of this string.
• effects (Microsoft.Xna.Framework.Graphics.SpriteEffects) – Modificators for drawing. Can be combined.
• layerDepth (float) – A depth of the layer of this string.

public void DrawString(SpriteFont spriteFont, string text, Vector2 position, Color color, float rotation, Vector2 origin, Vector2 scale, SpriteEffects effects, float layerDepth)

Submit a text string of sprites for drawing in the current batch.

Parameters:

• spriteFont (Microsoft.Xna.Framework.Graphics.SpriteFont) – A font.
• text (string) – The text which will be drawn.
• position (Microsoft.Xna.Framework.Vector2) – The drawing location on screen.
• color (Microsoft.Xna.Framework.Color) – A color mask.
• rotation (float) – A rotation of this string.
• origin (Microsoft.Xna.Framework.Vector2) – Center of the rotation. 0,0 by default.
• scale (Microsoft.Xna.Framework.Vector2) – A scaling of this string.
• effects (Microsoft.Xna.Framework.Graphics.SpriteEffects) – Modificators for drawing. Can be combined.
• layerDepth (float) – A depth of the layer of this string.

public void DrawString(SpriteFont spriteFont, System.Text.StringBuilder text, Vector2 position, Color color)

Submit a text string of sprites for drawing in the current batch.

Parameters:

• spriteFont (Microsoft.Xna.Framework.Graphics.SpriteFont) – A font.
• text (System.Text.StringBuilder) – The text which will be drawn.
• position (Microsoft.Xna.Framework.Vector2) – The drawing location on screen.
• color (Microsoft.Xna.Framework.Color) – A color mask.

public void DrawString(SpriteFont spriteFont, System.Text.StringBuilder text, Vector2 position, Color color, float rotation, Vector2 origin, float scale, SpriteEffects effects, float layerDepth)

Submit a text string of sprites for drawing in the current batch.

Parameters:

• spriteFont (Microsoft.Xna.Framework.Graphics.SpriteFont) – A font.
• text (System.Text.StringBuilder) – The text which will be drawn.
• position (Microsoft.Xna.Framework.Vector2) – The drawing location on screen.
• color (Microsoft.Xna.Framework.Color) – A color mask.
• rotation (float) – A rotation of this string.
• origin (Microsoft.Xna.Framework.Vector2) – Center of the rotation. 0,0 by default.
• scale (float) – A scaling of this string.
• effects (Microsoft.Xna.Framework.Graphics.SpriteEffects) – Modificators for drawing. Can be combined.
• layerDepth (float) – A depth of the layer of this string.

public void DrawString(SpriteFont spriteFont, System.Text.StringBuilder text, Vector2 position, Color color, float rotation, Vector2 origin, Vector2 scale, SpriteEffects effects, float layerDepth)

Submit a text string of sprites for drawing in the current batch.

Parameters:

• spriteFont (Microsoft.Xna.Framework.Graphics.SpriteFont) – A font.
• text (System.Text.StringBuilder) – The text which will be drawn.
• position (Microsoft.Xna.Framework.Vector2) – The drawing location on screen.
• color (Microsoft.Xna.Framework.Color) – A color mask.
• rotation (float) – A rotation of this string.
• origin (Microsoft.Xna.Framework.Vector2) – Center of the rotation. 0,0 by default.
• scale (Microsoft.Xna.Framework.Vector2) – A scaling of this string.
• effects (Microsoft.Xna.Framework.Graphics.SpriteEffects) – Modificators for drawing. Can be combined.
• layerDepth (float) – A depth of the layer of this string.

SpriteEffect

class SpriteEffect : Effect, System.IDisposable

The default effect used by SpriteBatch.

public Effect Clone()

Creates a clone of the current SpriteEffect instance.

void OnApply()

Lazily computes derived parameter values immediately before applying the effect.

SpriteEffects

enum SpriteEffects : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines sprite visual options for mirroring.

SpriteEffects None

No options specified.

SpriteEffects FlipHorizontally

Render the sprite reversed along the X axis.

SpriteEffects FlipVertically

Render the sprite reversed along the Y axis.

SpriteFont

class SpriteFont : System.Object

readonly Texture2D Texture

Gets the texture that this SpriteFont draws from.

readonly System.Collections.ObjectModel.ReadOnlyCollection<Char> Characters

Gets a collection of the characters in the font.

System.Nullable<Char> DefaultCharacter

Gets or sets the character that will be substituted when a given character is not included in the font.

int LineSpacing

Gets or sets the line spacing (the distance from baseline to baseline) of the font.

float Spacing

Gets or sets the spacing (tracking) between characters in the font.

System.Collections.Generic.Dictionary<Char, Glyph> get_Glyphs()

public System.Collections.Generic.Dictionary<Char, Glyph> GetGlyphs()

Returns a copy of the dictionary containing the glyphs in this SpriteFont.

Returns:A new Dictionary containing all of the glyphs inthis SpriteFont

public Vector2 MeasureString(string text)

Returns the size of a string when rendered in this font.

Parameters:

• text (string) – The text to measure.

Returns:

The size, in pixels, of ‘text’ when rendered in

this font.

public Vector2 MeasureString(System.Text.StringBuilder text)

Returns the size of the contents of a StringBuilder when rendered in this font.

Parameters:

• text (System.Text.StringBuilder) – The text to measure.

Returns:

The size, in pixels, of ‘text’ when rendered in

this font.

void MeasureString(ref Microsoft.Xna.Framework.Graphics.CharacterSource text, ref Vector2 size)

Parameters:

• (ref) text (Microsoft.Xna.Framework.Graphics.CharacterSource) –
• (ref) size (Microsoft.Xna.Framework.Vector2) –

SpriteSortMode

enum SpriteSortMode : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines sprite sort rendering options.

SpriteSortMode Deferred

All sprites are drawing when M:Microsoft.Xna.Framework.Graphics.SpriteBatch.End invokes, in order of draw call sequence. Depth is ignored.

SpriteSortMode Immediate

Each sprite is drawing at individual draw call, instead of M:Microsoft.Xna.Framework.Graphics.SpriteBatch.End. Depth is ignored.

SpriteSortMode Texture

Same as F:Microsoft.Xna.Framework.Graphics.SpriteSortMode.Deferred, except sprites are sorted by texture prior to drawing. Depth is ignored.

SpriteSortMode BackToFront

Same as F:Microsoft.Xna.Framework.Graphics.SpriteSortMode.Deferred, except sprites are sorted by depth in back-to-front order prior to drawing.

SpriteSortMode FrontToBack

Same as F:Microsoft.Xna.Framework.Graphics.SpriteSortMode.Deferred, except sprites are sorted by depth in front-to-back order prior to drawing.

StencilOperation

enum StencilOperation : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines stencil buffer operations.

StencilOperation Keep

Does not update the stencil buffer entry.

StencilOperation Zero

Sets the stencil buffer entry to 0.

StencilOperation Replace

Replaces the stencil buffer entry with a reference value.

StencilOperation Increment

Increments the stencil buffer entry, wrapping to 0 if the new value exceeds the maximum value.

StencilOperation Decrement

Decrements the stencil buffer entry, wrapping to the maximum value if the new value is less than 0.

StencilOperation IncrementSaturation

Increments the stencil buffer entry, clamping to the maximum value.

StencilOperation DecrementSaturation

Decrements the stencil buffer entry, clamping to 0.

StencilOperation Invert

Inverts the bits in the stencil buffer entry.

SurfaceFormat

enum SurfaceFormat : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines types of surface formats.

SurfaceFormat Color

Unsigned 32-bit ARGB pixel format for store 8 bits per channel.

SurfaceFormat Bgr565

Unsigned 16-bit BGR pixel format for store 5 bits for blue, 6 bits for green, and 5 bits for red.

SurfaceFormat Bgra5551

Unsigned 16-bit BGRA pixel format where 5 bits reserved for each color and last bit is reserved for alpha.

SurfaceFormat Bgra4444

Unsigned 16-bit BGRA pixel format for store 4 bits per channel.

SurfaceFormat Dxt1

DXT1. Texture format with compression. Surface dimensions must be a multiple 4.

SurfaceFormat Dxt3

DXT3. Texture format with compression. Surface dimensions must be a multiple 4.

SurfaceFormat Dxt5

DXT5. Texture format with compression. Surface dimensions must be a multiple 4.

SurfaceFormat NormalizedByte2

Signed 16-bit bump-map format for store 8 bits for u and v data.

SurfaceFormat NormalizedByte4

Signed 16-bit bump-map format for store 8 bits per channel.

SurfaceFormat Rgba1010102

Unsigned 32-bit RGBA pixel format for store 10 bits for each color and 2 bits for alpha.

SurfaceFormat Rg32

Unsigned 32-bit RG pixel format using 16 bits per channel.

SurfaceFormat Rgba64

Unsigned 64-bit RGBA pixel format using 16 bits per channel.

SurfaceFormat Alpha8

Unsigned A 8-bit format for store 8 bits to alpha channel.

SurfaceFormat Single

IEEE 32-bit R float format for store 32 bits to red channel.

SurfaceFormat Vector2

IEEE 64-bit RG float format for store 32 bits per channel.

SurfaceFormat Vector4

IEEE 128-bit RGBA float format for store 32 bits per channel.

SurfaceFormat HalfSingle

Float 16-bit R format for store 16 bits to red channel.

SurfaceFormat HalfVector2

Float 32-bit RG format for store 16 bits per channel.

SurfaceFormat HalfVector4

Float 64-bit ARGB format for store 16 bits per channel.

SurfaceFormat HdrBlendable

Float pixel format for high dynamic range data.

SurfaceFormat Bgr32

For compatibility with WPF D3DImage.

SurfaceFormat Bgra32

For compatibility with WPF D3DImage.

SurfaceFormat ColorSRgb

Unsigned 32-bit RGBA sRGB pixel format that supports 8 bits per channel.

SurfaceFormat Bgr32SRgb

Unsigned 32-bit sRGB pixel format that supports 8 bits per channel. 8 bits are unused.

SurfaceFormat Bgra32SRgb

Unsigned 32-bit sRGB pixel format that supports 8 bits per channel.

SurfaceFormat Dxt1SRgb

DXT1. sRGB texture format with compression. Surface dimensions must be a multiple of 4.

SurfaceFormat Dxt3SRgb

DXT3. sRGB texture format with compression. Surface dimensions must be a multiple of 4.

SurfaceFormat Dxt5SRgb

DXT5. sRGB texture format with compression. Surface dimensions must be a multiple of 4.

SurfaceFormat RgbPvrtc2Bpp

PowerVR texture compression format (iOS and Android).

SurfaceFormat RgbPvrtc4Bpp

PowerVR texture compression format (iOS and Android).

SurfaceFormat RgbaPvrtc2Bpp

PowerVR texture compression format (iOS and Android).

SurfaceFormat RgbaPvrtc4Bpp

PowerVR texture compression format (iOS and Android).

SurfaceFormat RgbEtc1

Ericcson Texture Compression (Android)

SurfaceFormat Dxt1a

DXT1 version where 1-bit alpha is used.

SurfaceFormat RgbaAtcExplicitAlpha

ATC/ATITC compression (Android)

SurfaceFormat RgbaAtcInterpolatedAlpha

ATC/ATITC compression (Android)

SwapChainRenderTarget

class SwapChainRenderTarget : RenderTarget2D, System.IDisposable, Microsoft.Xna.Framework.Graphics.IRenderTarget

A swap chain used for rendering to a secondary GameWindow.

PresentInterval PresentInterval

public void Present()

Displays the contents of the active back buffer to the screen.

TargetBlendState

class TargetBlendState : System.Object

BlendFunction AlphaBlendFunction

Blend AlphaDestinationBlend

Blend AlphaSourceBlend

BlendFunction ColorBlendFunction

Blend ColorDestinationBlend

Blend ColorSourceBlend

ColorWriteChannels ColorWriteChannels

TargetBlendState Clone(BlendState parent)

Parameters:

• parent (Microsoft.Xna.Framework.Graphics.BlendState) –

void GetState(ref SharpDX.Direct3D11.RenderTargetBlendDescription desc)

Parameters:

• (ref) desc (SharpDX.Direct3D11.RenderTargetBlendDescription) –

TextInputEventArgs

class TextInputEventArgs : System.EventArgs

This class is used for the game window’s TextInput event as EventArgs.

readonly char Character

readonly Keys Key

Texture

class Texture : GraphicsResource, System.IDisposable

readonly SurfaceFormat Format

readonly int LevelCount

int get_SortingKey()

int CalculateMipLevels(int width, int height, int depth)

Parameters:

• width (int) –
• height (int) –
• depth (int) –

int GetPitch(int width)

Parameters:

• width (int) –

void GraphicsDeviceResetting()

public System.IntPtr GetSharedHandle()

Gets the handle to a shared resource.

Returns:The handle of the shared resource, or F:System.IntPtr.Zero if the texture was not created as a shared resource.

abstract SharpDX.Direct3D11.Resource CreateTexture()

SharpDX.Direct3D11.Resource GetTexture()

SharpDX.Direct3D11.ShaderResourceView GetShaderResourceView()

Texture2D

class Texture2D : Texture, System.IDisposable

readonly Rectangle Bounds

Gets the dimensions of the texture

readonly int Width

readonly int Height

float get_TexelWidth()

float get_TexelHeight()

public void SetData<T>(int level, int arraySlice, System.Nullable<Rectangle> rect, Microsoft.Xna.Framework.Graphics.T[] data, int startIndex, int elementCount)

Type Parameters:  

• T –

Parameters:

• level (int) –
• arraySlice (int) –
• rect (System.Nullable<Rectangle>) –
• data (Microsoft.Xna.Framework.Graphics.T[]) –
• startIndex (int) –
• elementCount (int) –

public void SetData<T>(int level, System.Nullable<Rectangle> rect, Microsoft.Xna.Framework.Graphics.T[] data, int startIndex, int elementCount)

Type Parameters:  

• T –

Parameters:

• level (int) –
• rect (System.Nullable<Rectangle>) –
• data (Microsoft.Xna.Framework.Graphics.T[]) –
• startIndex (int) –
• elementCount (int) –

public void SetData<T>(Microsoft.Xna.Framework.Graphics.T[] data, int startIndex, int elementCount)

Type Parameters:  

• T –

Parameters:

• data (Microsoft.Xna.Framework.Graphics.T[]) –
• startIndex (int) –
• elementCount (int) –

public void SetData<T>(Microsoft.Xna.Framework.Graphics.T[] data)

Type Parameters:  

• T –

Parameters:

• data (Microsoft.Xna.Framework.Graphics.T[]) –

public void GetData<T>(int level, int arraySlice, System.Nullable<Rectangle> rect, Microsoft.Xna.Framework.Graphics.T[] data, int startIndex, int elementCount)

Type Parameters:  

• T –

Parameters:

• level (int) –
• arraySlice (int) –
• rect (System.Nullable<Rectangle>) –
• data (Microsoft.Xna.Framework.Graphics.T[]) –
• startIndex (int) –
• elementCount (int) –

public void GetData<T>(int level, System.Nullable<Rectangle> rect, Microsoft.Xna.Framework.Graphics.T[] data, int startIndex, int elementCount)

Type Parameters:  

• T –

Parameters:

• level (int) –
• rect (System.Nullable<Rectangle>) –
• data (Microsoft.Xna.Framework.Graphics.T[]) –
• startIndex (int) –
• elementCount (int) –

public void GetData<T>(Microsoft.Xna.Framework.Graphics.T[] data, int startIndex, int elementCount)

Type Parameters:  

• T –

Parameters:

• data (Microsoft.Xna.Framework.Graphics.T[]) –
• startIndex (int) –
• elementCount (int) –

public void GetData<T>(Microsoft.Xna.Framework.Graphics.T[] data)

Type Parameters:  

• T –

Parameters:

• data (Microsoft.Xna.Framework.Graphics.T[]) –

public Texture2D FromStream(GraphicsDevice graphicsDevice, System.IO.Stream stream)

Creates a Texture2D from a stream, supported formats bmp, gif, jpg, png, tif and dds (only for simple textures). May work with other formats, but will not work with tga files.

Parameters:

• graphicsDevice (Microsoft.Xna.Framework.Graphics.GraphicsDevice) –
• stream (System.IO.Stream) –

Returns:

public void SaveAsJpeg(System.IO.Stream stream, int width, int height)

Converts the texture to a JPG image

Parameters:

• stream (System.IO.Stream) – Destination for the image
• width (int) –
• height (int) –

public void SaveAsPng(System.IO.Stream stream, int width, int height)

Converts the texture to a PNG image

Parameters:

• stream (System.IO.Stream) – Destination for the image
• width (int) –
• height (int) –

public void Reload(System.IO.Stream textureStream)

Parameters:

• textureStream (System.IO.Stream) –

SharpDX.Direct3D11.Resource CreateTexture()

SharpDX.DXGI.SampleDescription GetTextureSampleDescription()

Texture3D

class Texture3D : Texture, System.IDisposable

readonly int Width

readonly int Height

readonly int Depth

public void SetData<T>(Microsoft.Xna.Framework.Graphics.T[] data)

Type Parameters:  

• T –

Parameters:

• data (Microsoft.Xna.Framework.Graphics.T[]) –

public void SetData<T>(Microsoft.Xna.Framework.Graphics.T[] data, int startIndex, int elementCount)

Type Parameters:  

• T –

Parameters:

• data (Microsoft.Xna.Framework.Graphics.T[]) –
• startIndex (int) –
• elementCount (int) –

public void SetData<T>(int level, int left, int top, int right, int bottom, int front, int back, Microsoft.Xna.Framework.Graphics.T[] data, int startIndex, int elementCount)

Type Parameters:  

• T –

Parameters:

• level (int) –
• left (int) –
• top (int) –
• right (int) –
• bottom (int) –
• front (int) –
• back (int) –
• data (Microsoft.Xna.Framework.Graphics.T[]) –
• startIndex (int) –
• elementCount (int) –

public void GetData<T>(int level, int left, int top, int right, int bottom, int front, int back, Microsoft.Xna.Framework.Graphics.T[] data, int startIndex, int elementCount)

Type Parameters:  

• T –

Parameters:

• level (int) –
• left (int) –
• top (int) –
• right (int) –
• bottom (int) –
• front (int) –
• back (int) –
• data (Microsoft.Xna.Framework.Graphics.T[]) –
• startIndex (int) –
• elementCount (int) –

public void GetData<T>(Microsoft.Xna.Framework.Graphics.T[] data, int startIndex, int elementCount)

Type Parameters:  

• T –

Parameters:

• data (Microsoft.Xna.Framework.Graphics.T[]) –
• startIndex (int) –
• elementCount (int) –

public void GetData<T>(Microsoft.Xna.Framework.Graphics.T[] data)

Type Parameters:  

• T –

Parameters:

• data (Microsoft.Xna.Framework.Graphics.T[]) –

SharpDX.Direct3D11.Resource CreateTexture()

TextureAddressMode

enum TextureAddressMode : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines modes for addressing texels using texture coordinates that are outside of the range of 0.0 to 1.0.

TextureAddressMode Wrap

Texels outside range will form the tile at every integer junction.

TextureAddressMode Clamp

Texels outside range will be set to color of 0.0 or 1.0 texel.

TextureAddressMode Mirror

Same as F:Microsoft.Xna.Framework.Graphics.TextureAddressMode.Wrap but tiles will also flipped at every integer junction.

TextureAddressMode Border

Texels outside range will be set to the border color.

TextureCollection

class TextureCollection : System.Object

Texture Item

void Clear()

void Dirty()

Marks all texture slots as dirty.

void SetTextures(GraphicsDevice device)

Parameters:

• device (Microsoft.Xna.Framework.Graphics.GraphicsDevice) –

void ClearTargets(GraphicsDevice device, Microsoft.Xna.Framework.Graphics.RenderTargetBinding[] targets)

Parameters:

• device (Microsoft.Xna.Framework.Graphics.GraphicsDevice) –
• targets (Microsoft.Xna.Framework.Graphics.RenderTargetBinding[]) –

TextureCube

class TextureCube : Texture, System.IDisposable

readonly int Size

Gets the width and height of the cube map face in pixels.

Value:The width and height of a cube map face in pixels.

public void GetData<T>(CubeMapFace cubeMapFace, Microsoft.Xna.Framework.Graphics.T[] data)

Type Parameters:  

• T –

Parameters:

• cubeMapFace (Microsoft.Xna.Framework.Graphics.CubeMapFace) –
• data (Microsoft.Xna.Framework.Graphics.T[]) –

public void GetData<T>(CubeMapFace cubeMapFace, Microsoft.Xna.Framework.Graphics.T[] data, int startIndex, int elementCount)

Type Parameters:  

• T –

Parameters:

• cubeMapFace (Microsoft.Xna.Framework.Graphics.CubeMapFace) –
• data (Microsoft.Xna.Framework.Graphics.T[]) –
• startIndex (int) –
• elementCount (int) –

public void GetData<T>(CubeMapFace cubeMapFace, int level, System.Nullable<Rectangle> rect, Microsoft.Xna.Framework.Graphics.T[] data, int startIndex, int elementCount)

Type Parameters:  

• T –

Parameters:

• cubeMapFace (Microsoft.Xna.Framework.Graphics.CubeMapFace) –
• level (int) –
• rect (System.Nullable<Rectangle>) –
• data (Microsoft.Xna.Framework.Graphics.T[]) –
• startIndex (int) –
• elementCount (int) –

public void SetData<T>(CubeMapFace face, Microsoft.Xna.Framework.Graphics.T[] data)

Type Parameters:  

• T –

Parameters:

• face (Microsoft.Xna.Framework.Graphics.CubeMapFace) –
• data (Microsoft.Xna.Framework.Graphics.T[]) –

public void SetData<T>(CubeMapFace face, Microsoft.Xna.Framework.Graphics.T[] data, int startIndex, int elementCount)

Type Parameters:  

• T –

Parameters:

• face (Microsoft.Xna.Framework.Graphics.CubeMapFace) –
• data (Microsoft.Xna.Framework.Graphics.T[]) –
• startIndex (int) –
• elementCount (int) –

public void SetData<T>(CubeMapFace face, int level, System.Nullable<Rectangle> rect, Microsoft.Xna.Framework.Graphics.T[] data, int startIndex, int elementCount)

Type Parameters:  

• T –

Parameters:

• face (Microsoft.Xna.Framework.Graphics.CubeMapFace) –
• level (int) –
• rect (System.Nullable<Rectangle>) –
• data (Microsoft.Xna.Framework.Graphics.T[]) –
• startIndex (int) –
• elementCount (int) –

SharpDX.Direct3D11.Resource CreateTexture()

TextureFilter

enum TextureFilter : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines filtering types for texture sampler.

TextureFilter Linear

Use linear filtering.

TextureFilter Point

Use point filtering.

TextureFilter Anisotropic

Use anisotropic filtering.

TextureFilter LinearMipPoint

Use linear filtering to shrink or expand, and point filtering between mipmap levels (mip).

TextureFilter PointMipLinear

Use point filtering to shrink (minify) or expand (magnify), and linear filtering between mipmap levels.

TextureFilter MinLinearMagPointMipLinear

Use linear filtering to shrink, point filtering to expand, and linear filtering between mipmap levels.

TextureFilter MinLinearMagPointMipPoint

Use linear filtering to shrink, point filtering to expand, and point filtering between mipmap levels.

TextureFilter MinPointMagLinearMipLinear

Use point filtering to shrink, linear filtering to expand, and linear filtering between mipmap levels.

TextureFilter MinPointMagLinearMipPoint

Use point filtering to shrink, linear filtering to expand, and point filtering between mipmap levels.

TextureFilterMode

enum TextureFilterMode : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Filtering modes for texture samplers.

TextureFilterMode Default

TextureFilterMode Comparison

TitleContainer

class TitleContainer : System.Object

string get_Location()

public System.IO.Stream OpenStream(string name)

Returns an open stream to an exsiting file in the title storage area.

Parameters:

• name (string) – The filepath relative to the title storage area.

Returns:

A open stream or null if the file is not found.

string NormalizeRelativePath(string name)

Parameters:

• name (string) –

TouchCollection

struct TouchCollection : System.ValueType, System.Collections.Generic.IList<TouchLocation>, System.Collections.Generic.ICollection<TouchLocation>, System.Collections.Generic.IEnumerable<TouchLocation>, System.Collections.IEnumerable

Provides state information for a touch screen enabled device.

readonly bool IsConnected

States if a touch screen is available.

readonly bool IsReadOnly

States if touch collection is read only.

TouchLocation Item

readonly int Count

Returns the number of T:Microsoft.Xna.Framework.Input.Touch.TouchLocation items that exist in the collection.

bool FindById(int id, ref TouchLocation touchLocation)

Parameters:

• id (int) –
• (ref) touchLocation (Microsoft.Xna.Framework.Input.Touch.TouchLocation) –

int IndexOf(TouchLocation item)

Returns the index of the first occurrence of specified T:Microsoft.Xna.Framework.Input.Touch.TouchLocation item in the collection.

Parameters:

• item (Microsoft.Xna.Framework.Input.Touch.TouchLocation) – T:Microsoft.Xna.Framework.Input.Touch.TouchLocation to query.

Returns:

void Insert(int index, TouchLocation item)

Inserts a T:Microsoft.Xna.Framework.Input.Touch.TouchLocation item into the indicated position.

Parameters:

• index (int) – The position to insert into.
• item (Microsoft.Xna.Framework.Input.Touch.TouchLocation) – The T:Microsoft.Xna.Framework.Input.Touch.TouchLocation item to insert.

void RemoveAt(int index)

Removes the T:Microsoft.Xna.Framework.Input.Touch.TouchLocation item at specified index.

Parameters:

• index (int) – Index of the item that will be removed from collection.

void Add(TouchLocation item)

Adds a T:Microsoft.Xna.Framework.Input.Touch.TouchLocation to the collection.

Parameters:

• item (Microsoft.Xna.Framework.Input.Touch.TouchLocation) – The T:Microsoft.Xna.Framework.Input.Touch.TouchLocation item to be added.

void Clear()

Clears all the items in collection.

bool Contains(TouchLocation item)

Returns true if specified T:Microsoft.Xna.Framework.Input.Touch.TouchLocation item exists in the collection, false otherwise./>

Parameters:

• item (Microsoft.Xna.Framework.Input.Touch.TouchLocation) – The T:Microsoft.Xna.Framework.Input.Touch.TouchLocation item to query for.

Returns:

Returns true if queried item is found, false otherwise.

void CopyTo(Microsoft.Xna.Framework.Input.Touch.TouchLocation[] array, int arrayIndex)

Copies the :ref:`T:Microsoft.Xna.Framework.Input.Touch.TouchLocation`collection to specified array starting from the given index.

Parameters:

• array (Microsoft.Xna.Framework.Input.Touch.TouchLocation[]) – The array to copy T:Microsoft.Xna.Framework.Input.Touch.TouchLocation items.
• arrayIndex (int) – The starting index of the copy operation.

bool Remove(TouchLocation item)

Removes the specified T:Microsoft.Xna.Framework.Input.Touch.TouchLocation item from the collection.

Parameters:

• item (Microsoft.Xna.Framework.Input.Touch.TouchLocation) – The T:Microsoft.Xna.Framework.Input.Touch.TouchLocation item to remove.

Returns:

Microsoft.Xna.Framework.Input.Touch.Enumerator GetEnumerator()

Returns an enumerator for the T:Microsoft.Xna.Framework.Input.Touch.TouchCollection.

Returns:Enumerable list of T:Microsoft.Xna.Framework.Input.Touch.TouchLocation objects.

TouchLocation

struct TouchLocation : System.ValueType, System.IEquatable<TouchLocation>

readonly int Id

readonly Vector2 Position

readonly float Pressure

readonly TouchLocationState State

Vector2 get_PressPosition()

System.TimeSpan get_PressTimestamp()

System.TimeSpan get_Timestamp()

Vector2 get_Velocity()

TouchLocation AsMovedState()

Returns a copy of the touch with the state changed to moved.

Returns:The new touch location.

bool UpdateState(TouchLocation touchEvent)

Updates the touch location using the new event.

Parameters:

• touchEvent (Microsoft.Xna.Framework.Input.Touch.TouchLocation) – The next event for this touch location.

bool Equals(System.Object obj)

Parameters:

• obj (System.Object) –

bool Equals(TouchLocation other)

Parameters:

• other (Microsoft.Xna.Framework.Input.Touch.TouchLocation) –

int GetHashCode()

string ToString()

bool TryGetPreviousLocation(ref TouchLocation aPreviousLocation)

Parameters:

• (ref) aPreviousLocation (Microsoft.Xna.Framework.Input.Touch.TouchLocation) –

bool op_Inequality(TouchLocation value1, TouchLocation value2)

Parameters:

• value1 (Microsoft.Xna.Framework.Input.Touch.TouchLocation) –
• value2 (Microsoft.Xna.Framework.Input.Touch.TouchLocation) –

bool op_Equality(TouchLocation value1, TouchLocation value2)

Parameters:

• value1 (Microsoft.Xna.Framework.Input.Touch.TouchLocation) –
• value2 (Microsoft.Xna.Framework.Input.Touch.TouchLocation) –

void AgeState()

TouchLocationState

enum TouchLocationState : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Holds the possible state information for a touch location..

TouchLocationState Invalid

This touch location position is invalid.

TouchLocationState Moved

This touch location position was updated or pressed at the same position.

TouchLocationState Pressed

This touch location position is new.

TouchLocationState Released

This touch location position was released.

TouchPanel

class TouchPanel : System.Object

Allows retrieval of information from Touch Panel device.

System.IntPtr WindowHandle

The window handle of the touch panel. Purely for Xna compatibility.

int DisplayHeight

Gets or sets the display height of the touch panel.

DisplayOrientation DisplayOrientation

Gets or sets the display orientation of the touch panel.

int DisplayWidth

Gets or sets the display width of the touch panel.

GestureType EnabledGestures

Gets or sets enabled gestures.

bool EnableMouseTouchPoint

bool EnableMouseGestures

readonly bool IsGestureAvailable

Returns true if a touch gesture is available.

public TouchCollection GetState()

Gets the current state of the touch panel.

Returns:T:Microsoft.Xna.Framework.Input.Touch.TouchCollection

public TouchPanelState GetState(GameWindow window)

Parameters:

• window (Microsoft.Xna.Framework.GameWindow) –

public TouchPanelCapabilities GetCapabilities()

void AddEvent(int id, TouchLocationState state, Vector2 position)

Parameters:

• id (int) –
• state (Microsoft.Xna.Framework.Input.Touch.TouchLocationState) –
• position (Microsoft.Xna.Framework.Vector2) –

void AddEvent(int id, TouchLocationState state, Vector2 position, bool isMouse)

Parameters:

• id (int) –
• state (Microsoft.Xna.Framework.Input.Touch.TouchLocationState) –
• position (Microsoft.Xna.Framework.Vector2) –
• isMouse (bool) –

public GestureSample ReadGesture()

Returns the next available gesture on touch panel device.

Returns:T:Microsoft.Xna.Framework.Input.Touch.GestureSample

TouchPanelCapabilities

struct TouchPanelCapabilities : System.ValueType

Allows retrieval of capabilities information from touch panel device.

readonly bool HasPressure

readonly bool IsConnected

Returns true if a device is available for use.

readonly int MaximumTouchCount

Returns the maximum number of touch locations tracked by the touch panel device.

void Initialize()

TouchPanelState

class TouchPanelState : System.Object

System.IntPtr WindowHandle

The window handle of the touch panel. Purely for Xna compatibility.

int DisplayHeight

Gets or sets the display height of the touch panel.

DisplayOrientation DisplayOrientation

Gets or sets the display orientation of the touch panel.

int DisplayWidth

Gets or sets the display width of the touch panel.

GestureType EnabledGestures

Gets or sets enabled gestures.

bool EnableMouseTouchPoint

bool EnableMouseGestures

readonly bool IsGestureAvailable

Returns true if a touch gesture is available.

System.TimeSpan get_CurrentTimestamp()

void set_CurrentTimestamp(System.TimeSpan value)

Parameters:

• value (System.TimeSpan) –

public TouchPanelCapabilities GetCapabilities()

Returns capabilities of touch panel device.

Returns:T:Microsoft.Xna.Framework.Input.Touch.TouchPanelCapabilities

public TouchCollection GetState()

void AddEvent(int id, TouchLocationState state, Vector2 position)

Parameters:

• id (int) –
• state (Microsoft.Xna.Framework.Input.Touch.TouchLocationState) –
• position (Microsoft.Xna.Framework.Vector2) –

void AddEvent(int id, TouchLocationState state, Vector2 position, bool isMouse)

Parameters:

• id (int) –
• state (Microsoft.Xna.Framework.Input.Touch.TouchLocationState) –
• position (Microsoft.Xna.Framework.Vector2) –
• isMouse (bool) –

void ReleaseAllTouches()

This will release all touch locations. It should only be called on platforms where touch state is reset all at once.

public GestureSample ReadGesture()

Returns the next available gesture on touch panel device.

Returns:T:Microsoft.Xna.Framework.Input.Touch.GestureSample

Vector2

struct Vector2 : System.ValueType, System.IEquatable<Vector2>

Describes a 2D-vector.

float X

The x coordinate of this T:Microsoft.Xna.Framework.Vector2.

float Y

The y coordinate of this T:Microsoft.Xna.Framework.Vector2.

readonly Vector2 Zero

Returns a T:Microsoft.Xna.Framework.Vector2 with components 0, 0.

readonly Vector2 One

Returns a T:Microsoft.Xna.Framework.Vector2 with components 1, 1.

readonly Vector2 UnitX

Returns a T:Microsoft.Xna.Framework.Vector2 with components 1, 0.

readonly Vector2 UnitY

Returns a T:Microsoft.Xna.Framework.Vector2 with components 0, 1.

string get_DebugDisplayString()

Vector2 op_UnaryNegation(Vector2 value)

Inverts values in the specified T:Microsoft.Xna.Framework.Vector2.

Parameters:

• value (Microsoft.Xna.Framework.Vector2) – Source T:Microsoft.Xna.Framework.Vector2 on the right of the sub sign.

Returns:

Result of the inversion.

Vector2 op_Addition(Vector2 value1, Vector2 value2)

Adds two vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector2) – Source T:Microsoft.Xna.Framework.Vector2 on the left of the add sign.
• value2 (Microsoft.Xna.Framework.Vector2) – Source T:Microsoft.Xna.Framework.Vector2 on the right of the add sign.

Returns:

Sum of the vectors.

Vector2 op_Subtraction(Vector2 value1, Vector2 value2)

Subtracts a T:Microsoft.Xna.Framework.Vector2 from a T:Microsoft.Xna.Framework.Vector2.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector2) – Source T:Microsoft.Xna.Framework.Vector2 on the left of the sub sign.
• value2 (Microsoft.Xna.Framework.Vector2) – Source T:Microsoft.Xna.Framework.Vector2 on the right of the sub sign.

Returns:

Result of the vector subtraction.

Vector2 op_Multiply(Vector2 value1, Vector2 value2)

Multiplies the components of two vectors by each other.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector2) – Source T:Microsoft.Xna.Framework.Vector2 on the left of the mul sign.
• value2 (Microsoft.Xna.Framework.Vector2) – Source T:Microsoft.Xna.Framework.Vector2 on the right of the mul sign.

Returns:

Result of the vector multiplication.

Vector2 op_Multiply(Vector2 value, float scaleFactor)

Multiplies the components of vector by a scalar.

Parameters:

• value (Microsoft.Xna.Framework.Vector2) – Source T:Microsoft.Xna.Framework.Vector2 on the left of the mul sign.
• scaleFactor (float) – Scalar value on the right of the mul sign.

Returns:

Result of the vector multiplication with a scalar.

Vector2 op_Multiply(float scaleFactor, Vector2 value)

Multiplies the components of vector by a scalar.

Parameters:

• scaleFactor (float) – Scalar value on the left of the mul sign.
• value (Microsoft.Xna.Framework.Vector2) – Source T:Microsoft.Xna.Framework.Vector2 on the right of the mul sign.

Returns:

Result of the vector multiplication with a scalar.

Vector2 op_Division(Vector2 value1, Vector2 value2)

Divides the components of a T:Microsoft.Xna.Framework.Vector2 by the components of another T:Microsoft.Xna.Framework.Vector2.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector2) – Source T:Microsoft.Xna.Framework.Vector2 on the left of the div sign.
• value2 (Microsoft.Xna.Framework.Vector2) – Divisor T:Microsoft.Xna.Framework.Vector2 on the right of the div sign.

Returns:

The result of dividing the vectors.

Vector2 op_Division(Vector2 value1, float divider)

Divides the components of a T:Microsoft.Xna.Framework.Vector2 by a scalar.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector2) – Source T:Microsoft.Xna.Framework.Vector2 on the left of the div sign.
• divider (float) – Divisor scalar on the right of the div sign.

Returns:

The result of dividing a vector by a scalar.

bool op_Equality(Vector2 value1, Vector2 value2)

Compares whether two T:Microsoft.Xna.Framework.Vector2 instances are equal.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector2) – T:Microsoft.Xna.Framework.Vector2 instance on the left of the equal sign.
• value2 (Microsoft.Xna.Framework.Vector2) – T:Microsoft.Xna.Framework.Vector2 instance on the right of the equal sign.

Returns:

true if the instances are equal; false otherwise.

bool op_Inequality(Vector2 value1, Vector2 value2)

Compares whether two T:Microsoft.Xna.Framework.Vector2 instances are not equal.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector2) – T:Microsoft.Xna.Framework.Vector2 instance on the left of the not equal sign.
• value2 (Microsoft.Xna.Framework.Vector2) – T:Microsoft.Xna.Framework.Vector2 instance on the right of the not equal sign.

Returns:

true if the instances are not equal; false otherwise.

Vector2 Add(Vector2 value1, Vector2 value2)

Performs vector addition on and .

Parameters:

• value1 (Microsoft.Xna.Framework.Vector2) – The first vector to add.
• value2 (Microsoft.Xna.Framework.Vector2) – The second vector to add.

Returns:

The result of the vector addition.

void Add(ref Vector2 value1, ref Vector2 value2, ref Vector2 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector2) –
• (ref) value2 (Microsoft.Xna.Framework.Vector2) –
• (ref) result (Microsoft.Xna.Framework.Vector2) –

Vector2 Barycentric(Vector2 value1, Vector2 value2, Vector2 value3, float amount1, float amount2)

Creates a new T:Microsoft.Xna.Framework.Vector2 that contains the cartesian coordinates of a vector specified in barycentric coordinates and relative to 2d-triangle.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector2) – The first vector of 2d-triangle.
• value2 (Microsoft.Xna.Framework.Vector2) – The second vector of 2d-triangle.
• value3 (Microsoft.Xna.Framework.Vector2) – The third vector of 2d-triangle.
• amount1 (float) – Barycentric scalar b2 which represents a weighting factor towards second vector of 2d-triangle.
• amount2 (float) – Barycentric scalar b3 which represents a weighting factor towards third vector of 2d-triangle.

Returns:

The cartesian translation of barycentric coordinates.

void Barycentric(ref Vector2 value1, ref Vector2 value2, ref Vector2 value3, float amount1, float amount2, ref Vector2 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector2) –
• (ref) value2 (Microsoft.Xna.Framework.Vector2) –
• (ref) value3 (Microsoft.Xna.Framework.Vector2) –
• amount1 (float) –
• amount2 (float) –
• (ref) result (Microsoft.Xna.Framework.Vector2) –

Vector2 CatmullRom(Vector2 value1, Vector2 value2, Vector2 value3, Vector2 value4, float amount)

Creates a new T:Microsoft.Xna.Framework.Vector2 that contains CatmullRom interpolation of the specified vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector2) – The first vector in interpolation.
• value2 (Microsoft.Xna.Framework.Vector2) – The second vector in interpolation.
• value3 (Microsoft.Xna.Framework.Vector2) – The third vector in interpolation.
• value4 (Microsoft.Xna.Framework.Vector2) – The fourth vector in interpolation.
• amount (float) – Weighting factor.

Returns:

The result of CatmullRom interpolation.

void CatmullRom(ref Vector2 value1, ref Vector2 value2, ref Vector2 value3, ref Vector2 value4, float amount, ref Vector2 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector2) –
• (ref) value2 (Microsoft.Xna.Framework.Vector2) –
• (ref) value3 (Microsoft.Xna.Framework.Vector2) –
• (ref) value4 (Microsoft.Xna.Framework.Vector2) –
• amount (float) –
• (ref) result (Microsoft.Xna.Framework.Vector2) –

Vector2 Clamp(Vector2 value1, Vector2 min, Vector2 max)

Clamps the specified value within a range.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector2) – The value to clamp.
• min (Microsoft.Xna.Framework.Vector2) – The min value.
• max (Microsoft.Xna.Framework.Vector2) – The max value.

Returns:

The clamped value.

void Clamp(ref Vector2 value1, ref Vector2 min, ref Vector2 max, ref Vector2 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector2) –
• (ref) min (Microsoft.Xna.Framework.Vector2) –
• (ref) max (Microsoft.Xna.Framework.Vector2) –
• (ref) result (Microsoft.Xna.Framework.Vector2) –

float Distance(Vector2 value1, Vector2 value2)

Returns the distance between two vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector2) – The first vector.
• value2 (Microsoft.Xna.Framework.Vector2) – The second vector.

Returns:

The distance between two vectors.

void Distance(ref Vector2 value1, ref Vector2 value2, ref float result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector2) –
• (ref) value2 (Microsoft.Xna.Framework.Vector2) –
• (ref) result (float) –

float DistanceSquared(Vector2 value1, Vector2 value2)

Returns the squared distance between two vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector2) – The first vector.
• value2 (Microsoft.Xna.Framework.Vector2) – The second vector.

Returns:

The squared distance between two vectors.

void DistanceSquared(ref Vector2 value1, ref Vector2 value2, ref float result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector2) –
• (ref) value2 (Microsoft.Xna.Framework.Vector2) –
• (ref) result (float) –

Vector2 Divide(Vector2 value1, Vector2 value2)

Divides the components of a T:Microsoft.Xna.Framework.Vector2 by the components of another T:Microsoft.Xna.Framework.Vector2.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector2) – Source T:Microsoft.Xna.Framework.Vector2.
• value2 (Microsoft.Xna.Framework.Vector2) – Divisor T:Microsoft.Xna.Framework.Vector2.

Returns:

The result of dividing the vectors.

void Divide(ref Vector2 value1, ref Vector2 value2, ref Vector2 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector2) –
• (ref) value2 (Microsoft.Xna.Framework.Vector2) –
• (ref) result (Microsoft.Xna.Framework.Vector2) –

Vector2 Divide(Vector2 value1, float divider)

Divides the components of a T:Microsoft.Xna.Framework.Vector2 by a scalar.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector2) – Source T:Microsoft.Xna.Framework.Vector2.
• divider (float) – Divisor scalar.

Returns:

The result of dividing a vector by a scalar.

void Divide(ref Vector2 value1, float divider, ref Vector2 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector2) –
• divider (float) –
• (ref) result (Microsoft.Xna.Framework.Vector2) –

float Dot(Vector2 value1, Vector2 value2)

Returns a dot product of two vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector2) – The first vector.
• value2 (Microsoft.Xna.Framework.Vector2) – The second vector.

Returns:

The dot product of two vectors.

void Dot(ref Vector2 value1, ref Vector2 value2, ref float result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector2) –
• (ref) value2 (Microsoft.Xna.Framework.Vector2) –
• (ref) result (float) –

bool Equals(System.Object obj)

Compares whether current instance is equal to specified T:System.Object.

Parameters:

• obj (System.Object) – The T:System.Object to compare.

Returns:

true if the instances are equal; false otherwise.

bool Equals(Vector2 other)

Compares whether current instance is equal to specified T:Microsoft.Xna.Framework.Vector2.

Parameters:

• other (Microsoft.Xna.Framework.Vector2) – The T:Microsoft.Xna.Framework.Vector2 to compare.

Returns:

true if the instances are equal; false otherwise.

int GetHashCode()

Gets the hash code of this T:Microsoft.Xna.Framework.Vector2.

Returns:Hash code of this T:Microsoft.Xna.Framework.Vector2.

Vector2 Hermite(Vector2 value1, Vector2 tangent1, Vector2 value2, Vector2 tangent2, float amount)

Creates a new T:Microsoft.Xna.Framework.Vector2 that contains hermite spline interpolation.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector2) – The first position vector.
• tangent1 (Microsoft.Xna.Framework.Vector2) – The first tangent vector.
• value2 (Microsoft.Xna.Framework.Vector2) – The second position vector.
• tangent2 (Microsoft.Xna.Framework.Vector2) – The second tangent vector.
• amount (float) – Weighting factor.

Returns:

The hermite spline interpolation vector.

void Hermite(ref Vector2 value1, ref Vector2 tangent1, ref Vector2 value2, ref Vector2 tangent2, float amount, ref Vector2 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector2) –
• (ref) tangent1 (Microsoft.Xna.Framework.Vector2) –
• (ref) value2 (Microsoft.Xna.Framework.Vector2) –
• (ref) tangent2 (Microsoft.Xna.Framework.Vector2) –
• amount (float) –
• (ref) result (Microsoft.Xna.Framework.Vector2) –

float Length()

Returns the length of this T:Microsoft.Xna.Framework.Vector2.

Returns:The length of this T:Microsoft.Xna.Framework.Vector2.

float LengthSquared()

Returns the squared length of this T:Microsoft.Xna.Framework.Vector2.

Returns:The squared length of this T:Microsoft.Xna.Framework.Vector2.

Vector2 Lerp(Vector2 value1, Vector2 value2, float amount)

Creates a new T:Microsoft.Xna.Framework.Vector2 that contains linear interpolation of the specified vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector2) – The first vector.
• value2 (Microsoft.Xna.Framework.Vector2) – The second vector.
• amount (float) – Weighting value(between 0.0 and 1.0).

Returns:

The result of linear interpolation of the specified vectors.

void Lerp(ref Vector2 value1, ref Vector2 value2, float amount, ref Vector2 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector2) –
• (ref) value2 (Microsoft.Xna.Framework.Vector2) –
• amount (float) –
• (ref) result (Microsoft.Xna.Framework.Vector2) –

Vector2 LerpPrecise(Vector2 value1, Vector2 value2, float amount)

Creates a new T:Microsoft.Xna.Framework.Vector2 that contains linear interpolation of the specified vectors. Uses M:Microsoft.Xna.Framework.MathHelper.LerpPrecise(System.Single,System.Single,System.Single) on MathHelper for the interpolation. Less efficient but more precise compared to M:Microsoft.Xna.Framework.Vector2.Lerp(Microsoft.Xna.Framework.Vector2,Microsoft.Xna.Framework.Vector2,System.Single). See remarks section of M:Microsoft.Xna.Framework.MathHelper.LerpPrecise(System.Single,System.Single,System.Single) on MathHelper for more info.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector2) – The first vector.
• value2 (Microsoft.Xna.Framework.Vector2) – The second vector.
• amount (float) – Weighting value(between 0.0 and 1.0).

Returns:

The result of linear interpolation of the specified vectors.

void LerpPrecise(ref Vector2 value1, ref Vector2 value2, float amount, ref Vector2 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector2) –
• (ref) value2 (Microsoft.Xna.Framework.Vector2) –
• amount (float) –
• (ref) result (Microsoft.Xna.Framework.Vector2) –

Vector2 Max(Vector2 value1, Vector2 value2)

Creates a new T:Microsoft.Xna.Framework.Vector2 that contains a maximal values from the two vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector2) – The first vector.
• value2 (Microsoft.Xna.Framework.Vector2) – The second vector.

Returns:

The T:Microsoft.Xna.Framework.Vector2 with maximal values from the two vectors.

void Max(ref Vector2 value1, ref Vector2 value2, ref Vector2 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector2) –
• (ref) value2 (Microsoft.Xna.Framework.Vector2) –
• (ref) result (Microsoft.Xna.Framework.Vector2) –

Vector2 Min(Vector2 value1, Vector2 value2)

Creates a new T:Microsoft.Xna.Framework.Vector2 that contains a minimal values from the two vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector2) – The first vector.
• value2 (Microsoft.Xna.Framework.Vector2) – The second vector.

Returns:

The T:Microsoft.Xna.Framework.Vector2 with minimal values from the two vectors.

void Min(ref Vector2 value1, ref Vector2 value2, ref Vector2 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector2) –
• (ref) value2 (Microsoft.Xna.Framework.Vector2) –
• (ref) result (Microsoft.Xna.Framework.Vector2) –

Vector2 Multiply(Vector2 value1, Vector2 value2)

Creates a new T:Microsoft.Xna.Framework.Vector2 that contains a multiplication of two vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector2) – Source T:Microsoft.Xna.Framework.Vector2.
• value2 (Microsoft.Xna.Framework.Vector2) – Source T:Microsoft.Xna.Framework.Vector2.

Returns:

The result of the vector multiplication.

void Multiply(ref Vector2 value1, ref Vector2 value2, ref Vector2 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector2) –
• (ref) value2 (Microsoft.Xna.Framework.Vector2) –
• (ref) result (Microsoft.Xna.Framework.Vector2) –

Vector2 Multiply(Vector2 value1, float scaleFactor)

Creates a new T:Microsoft.Xna.Framework.Vector2 that contains a multiplication of T:Microsoft.Xna.Framework.Vector2 and a scalar.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector2) – Source T:Microsoft.Xna.Framework.Vector2.
• scaleFactor (float) – Scalar value.

Returns:

The result of the vector multiplication with a scalar.

void Multiply(ref Vector2 value1, float scaleFactor, ref Vector2 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector2) –
• scaleFactor (float) –
• (ref) result (Microsoft.Xna.Framework.Vector2) –

Vector2 Negate(Vector2 value)

Creates a new T:Microsoft.Xna.Framework.Vector2 that contains the specified vector inversion.

Parameters:

• value (Microsoft.Xna.Framework.Vector2) – Source T:Microsoft.Xna.Framework.Vector2.

Returns:

The result of the vector inversion.

void Negate(ref Vector2 value, ref Vector2 result)

Parameters:

• (ref) value (Microsoft.Xna.Framework.Vector2) –
• (ref) result (Microsoft.Xna.Framework.Vector2) –

void Normalize()

Turns this T:Microsoft.Xna.Framework.Vector2 to a unit vector with the same direction.

Vector2 Normalize(Vector2 value)

Creates a new T:Microsoft.Xna.Framework.Vector2 that contains a normalized values from another vector.

Parameters:

• value (Microsoft.Xna.Framework.Vector2) – Source T:Microsoft.Xna.Framework.Vector2.

Returns:

Unit vector.

void Normalize(ref Vector2 value, ref Vector2 result)

Parameters:

• (ref) value (Microsoft.Xna.Framework.Vector2) –
• (ref) result (Microsoft.Xna.Framework.Vector2) –

Vector2 Reflect(Vector2 vector, Vector2 normal)

Creates a new T:Microsoft.Xna.Framework.Vector2 that contains reflect vector of the given vector and normal.

Parameters:

• vector (Microsoft.Xna.Framework.Vector2) – Source T:Microsoft.Xna.Framework.Vector2.
• normal (Microsoft.Xna.Framework.Vector2) – Reflection normal.

Returns:

Reflected vector.

void Reflect(ref Vector2 vector, ref Vector2 normal, ref Vector2 result)

Parameters:

• (ref) vector (Microsoft.Xna.Framework.Vector2) –
• (ref) normal (Microsoft.Xna.Framework.Vector2) –
• (ref) result (Microsoft.Xna.Framework.Vector2) –

Vector2 SmoothStep(Vector2 value1, Vector2 value2, float amount)

Creates a new T:Microsoft.Xna.Framework.Vector2 that contains cubic interpolation of the specified vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector2) – Source T:Microsoft.Xna.Framework.Vector2.
• value2 (Microsoft.Xna.Framework.Vector2) – Source T:Microsoft.Xna.Framework.Vector2.
• amount (float) – Weighting value.

Returns:

Cubic interpolation of the specified vectors.

void SmoothStep(ref Vector2 value1, ref Vector2 value2, float amount, ref Vector2 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector2) –
• (ref) value2 (Microsoft.Xna.Framework.Vector2) –
• amount (float) –
• (ref) result (Microsoft.Xna.Framework.Vector2) –

Vector2 Subtract(Vector2 value1, Vector2 value2)

Creates a new T:Microsoft.Xna.Framework.Vector2 that contains subtraction of on T:Microsoft.Xna.Framework.Vector2 from a another.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector2) – Source T:Microsoft.Xna.Framework.Vector2.
• value2 (Microsoft.Xna.Framework.Vector2) – Source T:Microsoft.Xna.Framework.Vector2.

Returns:

The result of the vector subtraction.

void Subtract(ref Vector2 value1, ref Vector2 value2, ref Vector2 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector2) –
• (ref) value2 (Microsoft.Xna.Framework.Vector2) –
• (ref) result (Microsoft.Xna.Framework.Vector2) –

string ToString()

Returns a T:System.String representation of this T:Microsoft.Xna.Framework.Vector2 in the format: {X:[F:Microsoft.Xna.Framework.Vector2.X] Y:[F:Microsoft.Xna.Framework.Vector2.Y]}

Returns:A T:System.String representation of this T:Microsoft.Xna.Framework.Vector2.

Point ToPoint()

Gets a T:Microsoft.Xna.Framework.Point representation for this object.

Returns:A T:Microsoft.Xna.Framework.Point representation for this object.

Vector2 Transform(Vector2 position, Matrix matrix)

Creates a new T:Microsoft.Xna.Framework.Vector2 that contains a transformation of 2d-vector by the specified T:Microsoft.Xna.Framework.Matrix.

Parameters:

• position (Microsoft.Xna.Framework.Vector2) – Source T:Microsoft.Xna.Framework.Vector2.
• matrix (Microsoft.Xna.Framework.Matrix) – The transformation T:Microsoft.Xna.Framework.Matrix.

Returns:

Transformed T:Microsoft.Xna.Framework.Vector2.

void Transform(ref Vector2 position, ref Matrix matrix, ref Vector2 result)

Parameters:

• (ref) position (Microsoft.Xna.Framework.Vector2) –
• (ref) matrix (Microsoft.Xna.Framework.Matrix) –
• (ref) result (Microsoft.Xna.Framework.Vector2) –

Vector2 Transform(Vector2 value, Quaternion rotation)

Creates a new T:Microsoft.Xna.Framework.Vector2 that contains a transformation of 2d-vector by the specified T:Microsoft.Xna.Framework.Quaternion, representing the rotation.

Parameters:

• value (Microsoft.Xna.Framework.Vector2) – Source T:Microsoft.Xna.Framework.Vector2.
• rotation (Microsoft.Xna.Framework.Quaternion) – The T:Microsoft.Xna.Framework.Quaternion which contains rotation transformation.

Returns:

Transformed T:Microsoft.Xna.Framework.Vector2.

void Transform(ref Vector2 value, ref Quaternion rotation, ref Vector2 result)

Parameters:

• (ref) value (Microsoft.Xna.Framework.Vector2) –
• (ref) rotation (Microsoft.Xna.Framework.Quaternion) –
• (ref) result (Microsoft.Xna.Framework.Vector2) –

void Transform(Microsoft.Xna.Framework.Vector2[] sourceArray, int sourceIndex, ref Matrix matrix, Microsoft.Xna.Framework.Vector2[] destinationArray, int destinationIndex, int length)

Parameters:

• sourceArray (Microsoft.Xna.Framework.Vector2[]) –
• sourceIndex (int) –
• (ref) matrix (Microsoft.Xna.Framework.Matrix) –
• destinationArray (Microsoft.Xna.Framework.Vector2[]) –
• destinationIndex (int) –
• length (int) –

void Transform(Microsoft.Xna.Framework.Vector2[] sourceArray, int sourceIndex, ref Quaternion rotation, Microsoft.Xna.Framework.Vector2[] destinationArray, int destinationIndex, int length)

Parameters:

• sourceArray (Microsoft.Xna.Framework.Vector2[]) –
• sourceIndex (int) –
• (ref) rotation (Microsoft.Xna.Framework.Quaternion) –
• destinationArray (Microsoft.Xna.Framework.Vector2[]) –
• destinationIndex (int) –
• length (int) –

void Transform(Microsoft.Xna.Framework.Vector2[] sourceArray, ref Matrix matrix, Microsoft.Xna.Framework.Vector2[] destinationArray)

Parameters:

• sourceArray (Microsoft.Xna.Framework.Vector2[]) –
• (ref) matrix (Microsoft.Xna.Framework.Matrix) –
• destinationArray (Microsoft.Xna.Framework.Vector2[]) –

void Transform(Microsoft.Xna.Framework.Vector2[] sourceArray, ref Quaternion rotation, Microsoft.Xna.Framework.Vector2[] destinationArray)

Parameters:

• sourceArray (Microsoft.Xna.Framework.Vector2[]) –
• (ref) rotation (Microsoft.Xna.Framework.Quaternion) –
• destinationArray (Microsoft.Xna.Framework.Vector2[]) –

Vector2 TransformNormal(Vector2 normal, Matrix matrix)

Creates a new T:Microsoft.Xna.Framework.Vector2 that contains a transformation of the specified normal by the specified T:Microsoft.Xna.Framework.Matrix.

Parameters:

• normal (Microsoft.Xna.Framework.Vector2) – Source T:Microsoft.Xna.Framework.Vector2 which represents a normal vector.
• matrix (Microsoft.Xna.Framework.Matrix) – The transformation T:Microsoft.Xna.Framework.Matrix.

Returns:

Transformed normal.

void TransformNormal(ref Vector2 normal, ref Matrix matrix, ref Vector2 result)

Parameters:

• (ref) normal (Microsoft.Xna.Framework.Vector2) –
• (ref) matrix (Microsoft.Xna.Framework.Matrix) –
• (ref) result (Microsoft.Xna.Framework.Vector2) –

void TransformNormal(Microsoft.Xna.Framework.Vector2[] sourceArray, int sourceIndex, ref Matrix matrix, Microsoft.Xna.Framework.Vector2[] destinationArray, int destinationIndex, int length)

Parameters:

• sourceArray (Microsoft.Xna.Framework.Vector2[]) –
• sourceIndex (int) –
• (ref) matrix (Microsoft.Xna.Framework.Matrix) –
• destinationArray (Microsoft.Xna.Framework.Vector2[]) –
• destinationIndex (int) –
• length (int) –

void TransformNormal(Microsoft.Xna.Framework.Vector2[] sourceArray, ref Matrix matrix, Microsoft.Xna.Framework.Vector2[] destinationArray)

Parameters:

• sourceArray (Microsoft.Xna.Framework.Vector2[]) –
• (ref) matrix (Microsoft.Xna.Framework.Matrix) –
• destinationArray (Microsoft.Xna.Framework.Vector2[]) –

Vector2TypeConverter

class Vector2TypeConverter : System.ComponentModel.TypeConverter

public bool CanConvertTo(System.ComponentModel.ITypeDescriptorContext context, System.Type destinationType)

Parameters:

• context (System.ComponentModel.ITypeDescriptorContext) –
• destinationType (System.Type) –

public System.Object ConvertTo(System.ComponentModel.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, System.Object value, System.Type destinationType)

Parameters:

• context (System.ComponentModel.ITypeDescriptorContext) –
• culture (System.Globalization.CultureInfo) –
• value (System.Object) –
• destinationType (System.Type) –

public bool CanConvertFrom(System.ComponentModel.ITypeDescriptorContext context, System.Type sourceType)

Parameters:

• context (System.ComponentModel.ITypeDescriptorContext) –
• sourceType (System.Type) –

public System.Object ConvertFrom(System.ComponentModel.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, System.Object value)

Parameters:

• context (System.ComponentModel.ITypeDescriptorContext) –
• culture (System.Globalization.CultureInfo) –
• value (System.Object) –

Vector3

struct Vector3 : System.ValueType, System.IEquatable<Vector3>

Describes a 3D-vector.

float X

The x coordinate of this T:Microsoft.Xna.Framework.Vector3.

float Y

The y coordinate of this T:Microsoft.Xna.Framework.Vector3.

float Z

The z coordinate of this T:Microsoft.Xna.Framework.Vector3.

readonly Vector3 Zero

Returns a T:Microsoft.Xna.Framework.Vector3 with components 0, 0, 0.

readonly Vector3 One

Returns a T:Microsoft.Xna.Framework.Vector3 with components 1, 1, 1.

readonly Vector3 UnitX

Returns a T:Microsoft.Xna.Framework.Vector3 with components 1, 0, 0.

readonly Vector3 UnitY

Returns a T:Microsoft.Xna.Framework.Vector3 with components 0, 1, 0.

readonly Vector3 UnitZ

Returns a T:Microsoft.Xna.Framework.Vector3 with components 0, 0, 1.

readonly Vector3 Up

Returns a T:Microsoft.Xna.Framework.Vector3 with components 0, 1, 0.

readonly Vector3 Down

Returns a T:Microsoft.Xna.Framework.Vector3 with components 0, -1, 0.

readonly Vector3 Right

Returns a T:Microsoft.Xna.Framework.Vector3 with components 1, 0, 0.

readonly Vector3 Left

Returns a T:Microsoft.Xna.Framework.Vector3 with components -1, 0, 0.

readonly Vector3 Forward

Returns a T:Microsoft.Xna.Framework.Vector3 with components 0, 0, -1.

readonly Vector3 Backward

Returns a T:Microsoft.Xna.Framework.Vector3 with components 0, 0, 1.

string get_DebugDisplayString()

Vector3 Add(Vector3 value1, Vector3 value2)

Performs vector addition on and .

Parameters:

• value1 (Microsoft.Xna.Framework.Vector3) – The first vector to add.
• value2 (Microsoft.Xna.Framework.Vector3) – The second vector to add.

Returns:

The result of the vector addition.

void Add(ref Vector3 value1, ref Vector3 value2, ref Vector3 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector3) –
• (ref) value2 (Microsoft.Xna.Framework.Vector3) –
• (ref) result (Microsoft.Xna.Framework.Vector3) –

Vector3 Barycentric(Vector3 value1, Vector3 value2, Vector3 value3, float amount1, float amount2)

Creates a new T:Microsoft.Xna.Framework.Vector3 that contains the cartesian coordinates of a vector specified in barycentric coordinates and relative to 3d-triangle.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector3) – The first vector of 3d-triangle.
• value2 (Microsoft.Xna.Framework.Vector3) – The second vector of 3d-triangle.
• value3 (Microsoft.Xna.Framework.Vector3) – The third vector of 3d-triangle.
• amount1 (float) – Barycentric scalar b2 which represents a weighting factor towards second vector of 3d-triangle.
• amount2 (float) – Barycentric scalar b3 which represents a weighting factor towards third vector of 3d-triangle.

Returns:

The cartesian translation of barycentric coordinates.

void Barycentric(ref Vector3 value1, ref Vector3 value2, ref Vector3 value3, float amount1, float amount2, ref Vector3 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector3) –
• (ref) value2 (Microsoft.Xna.Framework.Vector3) –
• (ref) value3 (Microsoft.Xna.Framework.Vector3) –
• amount1 (float) –
• amount2 (float) –
• (ref) result (Microsoft.Xna.Framework.Vector3) –

Vector3 CatmullRom(Vector3 value1, Vector3 value2, Vector3 value3, Vector3 value4, float amount)

Creates a new T:Microsoft.Xna.Framework.Vector3 that contains CatmullRom interpolation of the specified vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector3) – The first vector in interpolation.
• value2 (Microsoft.Xna.Framework.Vector3) – The second vector in interpolation.
• value3 (Microsoft.Xna.Framework.Vector3) – The third vector in interpolation.
• value4 (Microsoft.Xna.Framework.Vector3) – The fourth vector in interpolation.
• amount (float) – Weighting factor.

Returns:

The result of CatmullRom interpolation.

void CatmullRom(ref Vector3 value1, ref Vector3 value2, ref Vector3 value3, ref Vector3 value4, float amount, ref Vector3 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector3) –
• (ref) value2 (Microsoft.Xna.Framework.Vector3) –
• (ref) value3 (Microsoft.Xna.Framework.Vector3) –
• (ref) value4 (Microsoft.Xna.Framework.Vector3) –
• amount (float) –
• (ref) result (Microsoft.Xna.Framework.Vector3) –

Vector3 Clamp(Vector3 value1, Vector3 min, Vector3 max)

Clamps the specified value within a range.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector3) – The value to clamp.
• min (Microsoft.Xna.Framework.Vector3) – The min value.
• max (Microsoft.Xna.Framework.Vector3) – The max value.

Returns:

The clamped value.

void Clamp(ref Vector3 value1, ref Vector3 min, ref Vector3 max, ref Vector3 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector3) –
• (ref) min (Microsoft.Xna.Framework.Vector3) –
• (ref) max (Microsoft.Xna.Framework.Vector3) –
• (ref) result (Microsoft.Xna.Framework.Vector3) –

Vector3 Cross(Vector3 vector1, Vector3 vector2)

Computes the cross product of two vectors.

Parameters:

• vector1 (Microsoft.Xna.Framework.Vector3) – The first vector.
• vector2 (Microsoft.Xna.Framework.Vector3) – The second vector.

Returns:

The cross product of two vectors.

void Cross(ref Vector3 vector1, ref Vector3 vector2, ref Vector3 result)

Parameters:

• (ref) vector1 (Microsoft.Xna.Framework.Vector3) –
• (ref) vector2 (Microsoft.Xna.Framework.Vector3) –
• (ref) result (Microsoft.Xna.Framework.Vector3) –

float Distance(Vector3 value1, Vector3 value2)

Returns the distance between two vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector3) – The first vector.
• value2 (Microsoft.Xna.Framework.Vector3) – The second vector.

Returns:

The distance between two vectors.

void Distance(ref Vector3 value1, ref Vector3 value2, ref float result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector3) –
• (ref) value2 (Microsoft.Xna.Framework.Vector3) –
• (ref) result (float) –

float DistanceSquared(Vector3 value1, Vector3 value2)

Returns the squared distance between two vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector3) – The first vector.
• value2 (Microsoft.Xna.Framework.Vector3) – The second vector.

Returns:

The squared distance between two vectors.

void DistanceSquared(ref Vector3 value1, ref Vector3 value2, ref float result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector3) –
• (ref) value2 (Microsoft.Xna.Framework.Vector3) –
• (ref) result (float) –

Vector3 Divide(Vector3 value1, Vector3 value2)

Divides the components of a T:Microsoft.Xna.Framework.Vector3 by the components of another T:Microsoft.Xna.Framework.Vector3.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector3) – Source T:Microsoft.Xna.Framework.Vector3.
• value2 (Microsoft.Xna.Framework.Vector3) – Divisor T:Microsoft.Xna.Framework.Vector3.

Returns:

The result of dividing the vectors.

Vector3 Divide(Vector3 value1, float divider)

Divides the components of a T:Microsoft.Xna.Framework.Vector3 by a scalar.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector3) – Source T:Microsoft.Xna.Framework.Vector3.
• divider (float) – Divisor scalar.

Returns:

The result of dividing a vector by a scalar.

void Divide(ref Vector3 value1, float divider, ref Vector3 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector3) –
• divider (float) –
• (ref) result (Microsoft.Xna.Framework.Vector3) –

void Divide(ref Vector3 value1, ref Vector3 value2, ref Vector3 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector3) –
• (ref) value2 (Microsoft.Xna.Framework.Vector3) –
• (ref) result (Microsoft.Xna.Framework.Vector3) –

float Dot(Vector3 value1, Vector3 value2)

Returns a dot product of two vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector3) – The first vector.
• value2 (Microsoft.Xna.Framework.Vector3) – The second vector.

Returns:

The dot product of two vectors.

void Dot(ref Vector3 value1, ref Vector3 value2, ref float result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector3) –
• (ref) value2 (Microsoft.Xna.Framework.Vector3) –
• (ref) result (float) –

bool Equals(System.Object obj)

Compares whether current instance is equal to specified T:System.Object.

Parameters:

• obj (System.Object) – The T:System.Object to compare.

Returns:

true if the instances are equal; false otherwise.

bool Equals(Vector3 other)

Compares whether current instance is equal to specified T:Microsoft.Xna.Framework.Vector3.

Parameters:

• other (Microsoft.Xna.Framework.Vector3) – The T:Microsoft.Xna.Framework.Vector3 to compare.

Returns:

true if the instances are equal; false otherwise.

int GetHashCode()

Gets the hash code of this T:Microsoft.Xna.Framework.Vector3.

Returns:Hash code of this T:Microsoft.Xna.Framework.Vector3.

Vector3 Hermite(Vector3 value1, Vector3 tangent1, Vector3 value2, Vector3 tangent2, float amount)

Creates a new T:Microsoft.Xna.Framework.Vector3 that contains hermite spline interpolation.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector3) – The first position vector.
• tangent1 (Microsoft.Xna.Framework.Vector3) – The first tangent vector.
• value2 (Microsoft.Xna.Framework.Vector3) – The second position vector.
• tangent2 (Microsoft.Xna.Framework.Vector3) – The second tangent vector.
• amount (float) – Weighting factor.

Returns:

The hermite spline interpolation vector.

void Hermite(ref Vector3 value1, ref Vector3 tangent1, ref Vector3 value2, ref Vector3 tangent2, float amount, ref Vector3 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector3) –
• (ref) tangent1 (Microsoft.Xna.Framework.Vector3) –
• (ref) value2 (Microsoft.Xna.Framework.Vector3) –
• (ref) tangent2 (Microsoft.Xna.Framework.Vector3) –
• amount (float) –
• (ref) result (Microsoft.Xna.Framework.Vector3) –

float Length()

Returns the length of this T:Microsoft.Xna.Framework.Vector3.

Returns:The length of this T:Microsoft.Xna.Framework.Vector3.

float LengthSquared()

Returns the squared length of this T:Microsoft.Xna.Framework.Vector3.

Returns:The squared length of this T:Microsoft.Xna.Framework.Vector3.

Vector3 Lerp(Vector3 value1, Vector3 value2, float amount)

Creates a new T:Microsoft.Xna.Framework.Vector3 that contains linear interpolation of the specified vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector3) – The first vector.
• value2 (Microsoft.Xna.Framework.Vector3) – The second vector.
• amount (float) – Weighting value(between 0.0 and 1.0).

Returns:

The result of linear interpolation of the specified vectors.

void Lerp(ref Vector3 value1, ref Vector3 value2, float amount, ref Vector3 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector3) –
• (ref) value2 (Microsoft.Xna.Framework.Vector3) –
• amount (float) –
• (ref) result (Microsoft.Xna.Framework.Vector3) –

Vector3 LerpPrecise(Vector3 value1, Vector3 value2, float amount)

Creates a new T:Microsoft.Xna.Framework.Vector3 that contains linear interpolation of the specified vectors. Uses M:Microsoft.Xna.Framework.MathHelper.LerpPrecise(System.Single,System.Single,System.Single) on MathHelper for the interpolation. Less efficient but more precise compared to M:Microsoft.Xna.Framework.Vector3.Lerp(Microsoft.Xna.Framework.Vector3,Microsoft.Xna.Framework.Vector3,System.Single). See remarks section of M:Microsoft.Xna.Framework.MathHelper.LerpPrecise(System.Single,System.Single,System.Single) on MathHelper for more info.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector3) – The first vector.
• value2 (Microsoft.Xna.Framework.Vector3) – The second vector.
• amount (float) – Weighting value(between 0.0 and 1.0).

Returns:

The result of linear interpolation of the specified vectors.

void LerpPrecise(ref Vector3 value1, ref Vector3 value2, float amount, ref Vector3 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector3) –
• (ref) value2 (Microsoft.Xna.Framework.Vector3) –
• amount (float) –
• (ref) result (Microsoft.Xna.Framework.Vector3) –

Vector3 Max(Vector3 value1, Vector3 value2)

Creates a new T:Microsoft.Xna.Framework.Vector3 that contains a maximal values from the two vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector3) – The first vector.
• value2 (Microsoft.Xna.Framework.Vector3) – The second vector.

Returns:

The T:Microsoft.Xna.Framework.Vector3 with maximal values from the two vectors.

void Max(ref Vector3 value1, ref Vector3 value2, ref Vector3 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector3) –
• (ref) value2 (Microsoft.Xna.Framework.Vector3) –
• (ref) result (Microsoft.Xna.Framework.Vector3) –

Vector3 Min(Vector3 value1, Vector3 value2)

Creates a new T:Microsoft.Xna.Framework.Vector3 that contains a minimal values from the two vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector3) – The first vector.
• value2 (Microsoft.Xna.Framework.Vector3) – The second vector.

Returns:

The T:Microsoft.Xna.Framework.Vector3 with minimal values from the two vectors.

void Min(ref Vector3 value1, ref Vector3 value2, ref Vector3 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector3) –
• (ref) value2 (Microsoft.Xna.Framework.Vector3) –
• (ref) result (Microsoft.Xna.Framework.Vector3) –

Vector3 Multiply(Vector3 value1, Vector3 value2)

Creates a new T:Microsoft.Xna.Framework.Vector3 that contains a multiplication of two vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector3) – Source T:Microsoft.Xna.Framework.Vector3.
• value2 (Microsoft.Xna.Framework.Vector3) – Source T:Microsoft.Xna.Framework.Vector3.

Returns:

The result of the vector multiplication.

Vector3 Multiply(Vector3 value1, float scaleFactor)

Creates a new T:Microsoft.Xna.Framework.Vector3 that contains a multiplication of T:Microsoft.Xna.Framework.Vector3 and a scalar.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector3) – Source T:Microsoft.Xna.Framework.Vector3.
• scaleFactor (float) – Scalar value.

Returns:

The result of the vector multiplication with a scalar.

void Multiply(ref Vector3 value1, float scaleFactor, ref Vector3 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector3) –
• scaleFactor (float) –
• (ref) result (Microsoft.Xna.Framework.Vector3) –

void Multiply(ref Vector3 value1, ref Vector3 value2, ref Vector3 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector3) –
• (ref) value2 (Microsoft.Xna.Framework.Vector3) –
• (ref) result (Microsoft.Xna.Framework.Vector3) –

Vector3 Negate(Vector3 value)

Creates a new T:Microsoft.Xna.Framework.Vector3 that contains the specified vector inversion.

Parameters:

• value (Microsoft.Xna.Framework.Vector3) – Source T:Microsoft.Xna.Framework.Vector3.

Returns:

The result of the vector inversion.

void Negate(ref Vector3 value, ref Vector3 result)

Parameters:

• (ref) value (Microsoft.Xna.Framework.Vector3) –
• (ref) result (Microsoft.Xna.Framework.Vector3) –

void Normalize()

Turns this T:Microsoft.Xna.Framework.Vector3 to a unit vector with the same direction.

Vector3 Normalize(Vector3 value)

Creates a new T:Microsoft.Xna.Framework.Vector3 that contains a normalized values from another vector.

Parameters:

• value (Microsoft.Xna.Framework.Vector3) – Source T:Microsoft.Xna.Framework.Vector3.

Returns:

Unit vector.

void Normalize(ref Vector3 value, ref Vector3 result)

Parameters:

• (ref) value (Microsoft.Xna.Framework.Vector3) –
• (ref) result (Microsoft.Xna.Framework.Vector3) –

Vector3 Reflect(Vector3 vector, Vector3 normal)

Creates a new T:Microsoft.Xna.Framework.Vector3 that contains reflect vector of the given vector and normal.

Parameters:

• vector (Microsoft.Xna.Framework.Vector3) – Source T:Microsoft.Xna.Framework.Vector3.
• normal (Microsoft.Xna.Framework.Vector3) – Reflection normal.

Returns:

Reflected vector.

void Reflect(ref Vector3 vector, ref Vector3 normal, ref Vector3 result)

Parameters:

• (ref) vector (Microsoft.Xna.Framework.Vector3) –
• (ref) normal (Microsoft.Xna.Framework.Vector3) –
• (ref) result (Microsoft.Xna.Framework.Vector3) –

Vector3 SmoothStep(Vector3 value1, Vector3 value2, float amount)

Creates a new T:Microsoft.Xna.Framework.Vector3 that contains cubic interpolation of the specified vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector3) – Source T:Microsoft.Xna.Framework.Vector3.
• value2 (Microsoft.Xna.Framework.Vector3) – Source T:Microsoft.Xna.Framework.Vector3.
• amount (float) – Weighting value.

Returns:

Cubic interpolation of the specified vectors.

void SmoothStep(ref Vector3 value1, ref Vector3 value2, float amount, ref Vector3 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector3) –
• (ref) value2 (Microsoft.Xna.Framework.Vector3) –
• amount (float) –
• (ref) result (Microsoft.Xna.Framework.Vector3) –

Vector3 Subtract(Vector3 value1, Vector3 value2)

Creates a new T:Microsoft.Xna.Framework.Vector3 that contains subtraction of on T:Microsoft.Xna.Framework.Vector3 from a another.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector3) – Source T:Microsoft.Xna.Framework.Vector3.
• value2 (Microsoft.Xna.Framework.Vector3) – Source T:Microsoft.Xna.Framework.Vector3.

Returns:

The result of the vector subtraction.

void Subtract(ref Vector3 value1, ref Vector3 value2, ref Vector3 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector3) –
• (ref) value2 (Microsoft.Xna.Framework.Vector3) –
• (ref) result (Microsoft.Xna.Framework.Vector3) –

string ToString()

Returns a T:System.String representation of this T:Microsoft.Xna.Framework.Vector3 in the format: {X:[F:Microsoft.Xna.Framework.Vector3.X] Y:[F:Microsoft.Xna.Framework.Vector3.Y] Z:[F:Microsoft.Xna.Framework.Vector3.Z]}

Returns:A T:System.String representation of this T:Microsoft.Xna.Framework.Vector3.

Vector3 Transform(Vector3 position, Matrix matrix)

Creates a new T:Microsoft.Xna.Framework.Vector3 that contains a transformation of 3d-vector by the specified T:Microsoft.Xna.Framework.Matrix.

Parameters:

• position (Microsoft.Xna.Framework.Vector3) – Source T:Microsoft.Xna.Framework.Vector3.
• matrix (Microsoft.Xna.Framework.Matrix) – The transformation T:Microsoft.Xna.Framework.Matrix.

Returns:

Transformed T:Microsoft.Xna.Framework.Vector3.

void Transform(ref Vector3 position, ref Matrix matrix, ref Vector3 result)

Parameters:

• (ref) position (Microsoft.Xna.Framework.Vector3) –
• (ref) matrix (Microsoft.Xna.Framework.Matrix) –
• (ref) result (Microsoft.Xna.Framework.Vector3) –

Vector3 Transform(Vector3 value, Quaternion rotation)

Creates a new T:Microsoft.Xna.Framework.Vector3 that contains a transformation of 3d-vector by the specified T:Microsoft.Xna.Framework.Quaternion, representing the rotation.

Parameters:

• value (Microsoft.Xna.Framework.Vector3) – Source T:Microsoft.Xna.Framework.Vector3.
• rotation (Microsoft.Xna.Framework.Quaternion) – The T:Microsoft.Xna.Framework.Quaternion which contains rotation transformation.

Returns:

Transformed T:Microsoft.Xna.Framework.Vector3.

void Transform(ref Vector3 value, ref Quaternion rotation, ref Vector3 result)

Parameters:

• (ref) value (Microsoft.Xna.Framework.Vector3) –
• (ref) rotation (Microsoft.Xna.Framework.Quaternion) –
• (ref) result (Microsoft.Xna.Framework.Vector3) –

void Transform(Microsoft.Xna.Framework.Vector3[] sourceArray, int sourceIndex, ref Matrix matrix, Microsoft.Xna.Framework.Vector3[] destinationArray, int destinationIndex, int length)

Parameters:

• sourceArray (Microsoft.Xna.Framework.Vector3[]) –
• sourceIndex (int) –
• (ref) matrix (Microsoft.Xna.Framework.Matrix) –
• destinationArray (Microsoft.Xna.Framework.Vector3[]) –
• destinationIndex (int) –
• length (int) –

void Transform(Microsoft.Xna.Framework.Vector3[] sourceArray, int sourceIndex, ref Quaternion rotation, Microsoft.Xna.Framework.Vector3[] destinationArray, int destinationIndex, int length)

Parameters:

• sourceArray (Microsoft.Xna.Framework.Vector3[]) –
• sourceIndex (int) –
• (ref) rotation (Microsoft.Xna.Framework.Quaternion) –
• destinationArray (Microsoft.Xna.Framework.Vector3[]) –
• destinationIndex (int) –
• length (int) –

void Transform(Microsoft.Xna.Framework.Vector3[] sourceArray, ref Matrix matrix, Microsoft.Xna.Framework.Vector3[] destinationArray)

Parameters:

• sourceArray (Microsoft.Xna.Framework.Vector3[]) –
• (ref) matrix (Microsoft.Xna.Framework.Matrix) –
• destinationArray (Microsoft.Xna.Framework.Vector3[]) –

void Transform(Microsoft.Xna.Framework.Vector3[] sourceArray, ref Quaternion rotation, Microsoft.Xna.Framework.Vector3[] destinationArray)

Parameters:

• sourceArray (Microsoft.Xna.Framework.Vector3[]) –
• (ref) rotation (Microsoft.Xna.Framework.Quaternion) –
• destinationArray (Microsoft.Xna.Framework.Vector3[]) –

Vector3 TransformNormal(Vector3 normal, Matrix matrix)

Creates a new T:Microsoft.Xna.Framework.Vector3 that contains a transformation of the specified normal by the specified T:Microsoft.Xna.Framework.Matrix.

Parameters:

• normal (Microsoft.Xna.Framework.Vector3) – Source T:Microsoft.Xna.Framework.Vector3 which represents a normal vector.
• matrix (Microsoft.Xna.Framework.Matrix) – The transformation T:Microsoft.Xna.Framework.Matrix.

Returns:

Transformed normal.

void TransformNormal(ref Vector3 normal, ref Matrix matrix, ref Vector3 result)

Parameters:

• (ref) normal (Microsoft.Xna.Framework.Vector3) –
• (ref) matrix (Microsoft.Xna.Framework.Matrix) –
• (ref) result (Microsoft.Xna.Framework.Vector3) –

void TransformNormal(Microsoft.Xna.Framework.Vector3[] sourceArray, int sourceIndex, ref Matrix matrix, Microsoft.Xna.Framework.Vector3[] destinationArray, int destinationIndex, int length)

Parameters:

• sourceArray (Microsoft.Xna.Framework.Vector3[]) –
• sourceIndex (int) –
• (ref) matrix (Microsoft.Xna.Framework.Matrix) –
• destinationArray (Microsoft.Xna.Framework.Vector3[]) –
• destinationIndex (int) –
• length (int) –

void TransformNormal(Microsoft.Xna.Framework.Vector3[] sourceArray, ref Matrix matrix, Microsoft.Xna.Framework.Vector3[] destinationArray)

Parameters:

• sourceArray (Microsoft.Xna.Framework.Vector3[]) –
• (ref) matrix (Microsoft.Xna.Framework.Matrix) –
• destinationArray (Microsoft.Xna.Framework.Vector3[]) –

bool op_Equality(Vector3 value1, Vector3 value2)

Compares whether two T:Microsoft.Xna.Framework.Vector3 instances are equal.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector3) – T:Microsoft.Xna.Framework.Vector3 instance on the left of the equal sign.
• value2 (Microsoft.Xna.Framework.Vector3) – T:Microsoft.Xna.Framework.Vector3 instance on the right of the equal sign.

Returns:

true if the instances are equal; false otherwise.

bool op_Inequality(Vector3 value1, Vector3 value2)

Compares whether two T:Microsoft.Xna.Framework.Vector3 instances are not equal.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector3) – T:Microsoft.Xna.Framework.Vector3 instance on the left of the not equal sign.
• value2 (Microsoft.Xna.Framework.Vector3) – T:Microsoft.Xna.Framework.Vector3 instance on the right of the not equal sign.

Returns:

true if the instances are not equal; false otherwise.

Vector3 op_Addition(Vector3 value1, Vector3 value2)

Adds two vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector3) – Source T:Microsoft.Xna.Framework.Vector3 on the left of the add sign.
• value2 (Microsoft.Xna.Framework.Vector3) – Source T:Microsoft.Xna.Framework.Vector3 on the right of the add sign.

Returns:

Sum of the vectors.

Vector3 op_UnaryNegation(Vector3 value)

Inverts values in the specified T:Microsoft.Xna.Framework.Vector3.

Parameters:

• value (Microsoft.Xna.Framework.Vector3) – Source T:Microsoft.Xna.Framework.Vector3 on the right of the sub sign.

Returns:

Result of the inversion.

Vector3 op_Subtraction(Vector3 value1, Vector3 value2)

Subtracts a T:Microsoft.Xna.Framework.Vector3 from a T:Microsoft.Xna.Framework.Vector3.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector3) – Source T:Microsoft.Xna.Framework.Vector3 on the left of the sub sign.
• value2 (Microsoft.Xna.Framework.Vector3) – Source T:Microsoft.Xna.Framework.Vector3 on the right of the sub sign.

Returns:

Result of the vector subtraction.

Vector3 op_Multiply(Vector3 value1, Vector3 value2)

Multiplies the components of two vectors by each other.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector3) – Source T:Microsoft.Xna.Framework.Vector3 on the left of the mul sign.
• value2 (Microsoft.Xna.Framework.Vector3) – Source T:Microsoft.Xna.Framework.Vector3 on the right of the mul sign.

Returns:

Result of the vector multiplication.

Vector3 op_Multiply(Vector3 value, float scaleFactor)

Multiplies the components of vector by a scalar.

Parameters:

• value (Microsoft.Xna.Framework.Vector3) – Source T:Microsoft.Xna.Framework.Vector3 on the left of the mul sign.
• scaleFactor (float) – Scalar value on the right of the mul sign.

Returns:

Result of the vector multiplication with a scalar.

Vector3 op_Multiply(float scaleFactor, Vector3 value)

Multiplies the components of vector by a scalar.

Parameters:

• scaleFactor (float) – Scalar value on the left of the mul sign.
• value (Microsoft.Xna.Framework.Vector3) – Source T:Microsoft.Xna.Framework.Vector3 on the right of the mul sign.

Returns:

Result of the vector multiplication with a scalar.

Vector3 op_Division(Vector3 value1, Vector3 value2)

Divides the components of a T:Microsoft.Xna.Framework.Vector3 by the components of another T:Microsoft.Xna.Framework.Vector3.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector3) – Source T:Microsoft.Xna.Framework.Vector3 on the left of the div sign.
• value2 (Microsoft.Xna.Framework.Vector3) – Divisor T:Microsoft.Xna.Framework.Vector3 on the right of the div sign.

Returns:

The result of dividing the vectors.

Vector3 op_Division(Vector3 value1, float divider)

Divides the components of a T:Microsoft.Xna.Framework.Vector3 by a scalar.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector3) – Source T:Microsoft.Xna.Framework.Vector3 on the left of the div sign.
• divider (float) – Divisor scalar on the right of the div sign.

Returns:

The result of dividing a vector by a scalar.

Vector3TypeConverter

class Vector3TypeConverter : System.ComponentModel.TypeConverter

public bool CanConvertTo(System.ComponentModel.ITypeDescriptorContext context, System.Type destinationType)

Parameters:

• context (System.ComponentModel.ITypeDescriptorContext) –
• destinationType (System.Type) –

public System.Object ConvertTo(System.ComponentModel.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, System.Object value, System.Type destinationType)

Parameters:

• context (System.ComponentModel.ITypeDescriptorContext) –
• culture (System.Globalization.CultureInfo) –
• value (System.Object) –
• destinationType (System.Type) –

public bool CanConvertFrom(System.ComponentModel.ITypeDescriptorContext context, System.Type sourceType)

Parameters:

• context (System.ComponentModel.ITypeDescriptorContext) –
• sourceType (System.Type) –

public System.Object ConvertFrom(System.ComponentModel.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, System.Object value)

Parameters:

• context (System.ComponentModel.ITypeDescriptorContext) –
• culture (System.Globalization.CultureInfo) –
• value (System.Object) –

Vector4

struct Vector4 : System.ValueType, System.IEquatable<Vector4>

Describes a 4D-vector.

float X

The x coordinate of this T:Microsoft.Xna.Framework.Vector4.

float Y

The y coordinate of this T:Microsoft.Xna.Framework.Vector4.

float Z

The z coordinate of this T:Microsoft.Xna.Framework.Vector4.

float W

The w coordinate of this T:Microsoft.Xna.Framework.Vector4.

readonly Vector4 Zero

Returns a T:Microsoft.Xna.Framework.Vector4 with components 0, 0, 0, 0.

readonly Vector4 One

Returns a T:Microsoft.Xna.Framework.Vector4 with components 1, 1, 1, 1.

readonly Vector4 UnitX

Returns a T:Microsoft.Xna.Framework.Vector4 with components 1, 0, 0, 0.

readonly Vector4 UnitY

Returns a T:Microsoft.Xna.Framework.Vector4 with components 0, 1, 0, 0.

readonly Vector4 UnitZ

Returns a T:Microsoft.Xna.Framework.Vector4 with components 0, 0, 1, 0.

readonly Vector4 UnitW

Returns a T:Microsoft.Xna.Framework.Vector4 with components 0, 0, 0, 1.

string get_DebugDisplayString()

Vector4 Add(Vector4 value1, Vector4 value2)

Performs vector addition on and .

Parameters:

• value1 (Microsoft.Xna.Framework.Vector4) – The first vector to add.
• value2 (Microsoft.Xna.Framework.Vector4) – The second vector to add.

Returns:

The result of the vector addition.

void Add(ref Vector4 value1, ref Vector4 value2, ref Vector4 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector4) –
• (ref) value2 (Microsoft.Xna.Framework.Vector4) –
• (ref) result (Microsoft.Xna.Framework.Vector4) –

Vector4 Barycentric(Vector4 value1, Vector4 value2, Vector4 value3, float amount1, float amount2)

Creates a new T:Microsoft.Xna.Framework.Vector4 that contains the cartesian coordinates of a vector specified in barycentric coordinates and relative to 4d-triangle.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector4) – The first vector of 4d-triangle.
• value2 (Microsoft.Xna.Framework.Vector4) – The second vector of 4d-triangle.
• value3 (Microsoft.Xna.Framework.Vector4) – The third vector of 4d-triangle.
• amount1 (float) – Barycentric scalar b2 which represents a weighting factor towards second vector of 4d-triangle.
• amount2 (float) – Barycentric scalar b3 which represents a weighting factor towards third vector of 4d-triangle.

Returns:

The cartesian translation of barycentric coordinates.

void Barycentric(ref Vector4 value1, ref Vector4 value2, ref Vector4 value3, float amount1, float amount2, ref Vector4 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector4) –
• (ref) value2 (Microsoft.Xna.Framework.Vector4) –
• (ref) value3 (Microsoft.Xna.Framework.Vector4) –
• amount1 (float) –
• amount2 (float) –
• (ref) result (Microsoft.Xna.Framework.Vector4) –

Vector4 CatmullRom(Vector4 value1, Vector4 value2, Vector4 value3, Vector4 value4, float amount)

Creates a new T:Microsoft.Xna.Framework.Vector4 that contains CatmullRom interpolation of the specified vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector4) – The first vector in interpolation.
• value2 (Microsoft.Xna.Framework.Vector4) – The second vector in interpolation.
• value3 (Microsoft.Xna.Framework.Vector4) – The third vector in interpolation.
• value4 (Microsoft.Xna.Framework.Vector4) – The fourth vector in interpolation.
• amount (float) – Weighting factor.

Returns:

The result of CatmullRom interpolation.

void CatmullRom(ref Vector4 value1, ref Vector4 value2, ref Vector4 value3, ref Vector4 value4, float amount, ref Vector4 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector4) –
• (ref) value2 (Microsoft.Xna.Framework.Vector4) –
• (ref) value3 (Microsoft.Xna.Framework.Vector4) –
• (ref) value4 (Microsoft.Xna.Framework.Vector4) –
• amount (float) –
• (ref) result (Microsoft.Xna.Framework.Vector4) –

Vector4 Clamp(Vector4 value1, Vector4 min, Vector4 max)

Clamps the specified value within a range.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector4) – The value to clamp.
• min (Microsoft.Xna.Framework.Vector4) – The min value.
• max (Microsoft.Xna.Framework.Vector4) – The max value.

Returns:

The clamped value.

void Clamp(ref Vector4 value1, ref Vector4 min, ref Vector4 max, ref Vector4 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector4) –
• (ref) min (Microsoft.Xna.Framework.Vector4) –
• (ref) max (Microsoft.Xna.Framework.Vector4) –
• (ref) result (Microsoft.Xna.Framework.Vector4) –

float Distance(Vector4 value1, Vector4 value2)

Returns the distance between two vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector4) – The first vector.
• value2 (Microsoft.Xna.Framework.Vector4) – The second vector.

Returns:

The distance between two vectors.

void Distance(ref Vector4 value1, ref Vector4 value2, ref float result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector4) –
• (ref) value2 (Microsoft.Xna.Framework.Vector4) –
• (ref) result (float) –

float DistanceSquared(Vector4 value1, Vector4 value2)

Returns the squared distance between two vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector4) – The first vector.
• value2 (Microsoft.Xna.Framework.Vector4) – The second vector.

Returns:

The squared distance between two vectors.

void DistanceSquared(ref Vector4 value1, ref Vector4 value2, ref float result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector4) –
• (ref) value2 (Microsoft.Xna.Framework.Vector4) –
• (ref) result (float) –

Vector4 Divide(Vector4 value1, Vector4 value2)

Divides the components of a T:Microsoft.Xna.Framework.Vector4 by the components of another T:Microsoft.Xna.Framework.Vector4.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector4) – Source T:Microsoft.Xna.Framework.Vector4.
• value2 (Microsoft.Xna.Framework.Vector4) – Divisor T:Microsoft.Xna.Framework.Vector4.

Returns:

The result of dividing the vectors.

Vector4 Divide(Vector4 value1, float divider)

Divides the components of a T:Microsoft.Xna.Framework.Vector4 by a scalar.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector4) – Source T:Microsoft.Xna.Framework.Vector4.
• divider (float) – Divisor scalar.

Returns:

The result of dividing a vector by a scalar.

void Divide(ref Vector4 value1, float divider, ref Vector4 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector4) –
• divider (float) –
• (ref) result (Microsoft.Xna.Framework.Vector4) –

void Divide(ref Vector4 value1, ref Vector4 value2, ref Vector4 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector4) –
• (ref) value2 (Microsoft.Xna.Framework.Vector4) –
• (ref) result (Microsoft.Xna.Framework.Vector4) –

float Dot(Vector4 value1, Vector4 value2)

Returns a dot product of two vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector4) – The first vector.
• value2 (Microsoft.Xna.Framework.Vector4) – The second vector.

Returns:

The dot product of two vectors.

void Dot(ref Vector4 value1, ref Vector4 value2, ref float result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector4) –
• (ref) value2 (Microsoft.Xna.Framework.Vector4) –
• (ref) result (float) –

bool Equals(System.Object obj)

Compares whether current instance is equal to specified T:System.Object.

Parameters:

• obj (System.Object) – The T:System.Object to compare.

Returns:

true if the instances are equal; false otherwise.

bool Equals(Vector4 other)

Compares whether current instance is equal to specified T:Microsoft.Xna.Framework.Vector4.

Parameters:

• other (Microsoft.Xna.Framework.Vector4) – The T:Microsoft.Xna.Framework.Vector4 to compare.

Returns:

true if the instances are equal; false otherwise.

int GetHashCode()

Gets the hash code of this T:Microsoft.Xna.Framework.Vector4.

Returns:Hash code of this T:Microsoft.Xna.Framework.Vector4.

Vector4 Hermite(Vector4 value1, Vector4 tangent1, Vector4 value2, Vector4 tangent2, float amount)

Creates a new T:Microsoft.Xna.Framework.Vector4 that contains hermite spline interpolation.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector4) – The first position vector.
• tangent1 (Microsoft.Xna.Framework.Vector4) – The first tangent vector.
• value2 (Microsoft.Xna.Framework.Vector4) – The second position vector.
• tangent2 (Microsoft.Xna.Framework.Vector4) – The second tangent vector.
• amount (float) – Weighting factor.

Returns:

The hermite spline interpolation vector.

void Hermite(ref Vector4 value1, ref Vector4 tangent1, ref Vector4 value2, ref Vector4 tangent2, float amount, ref Vector4 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector4) –
• (ref) tangent1 (Microsoft.Xna.Framework.Vector4) –
• (ref) value2 (Microsoft.Xna.Framework.Vector4) –
• (ref) tangent2 (Microsoft.Xna.Framework.Vector4) –
• amount (float) –
• (ref) result (Microsoft.Xna.Framework.Vector4) –

float Length()

Returns the length of this T:Microsoft.Xna.Framework.Vector4.

Returns:The length of this T:Microsoft.Xna.Framework.Vector4.

float LengthSquared()

Returns the squared length of this T:Microsoft.Xna.Framework.Vector4.

Returns:The squared length of this T:Microsoft.Xna.Framework.Vector4.

Vector4 Lerp(Vector4 value1, Vector4 value2, float amount)

Creates a new T:Microsoft.Xna.Framework.Vector4 that contains linear interpolation of the specified vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector4) – The first vector.
• value2 (Microsoft.Xna.Framework.Vector4) – The second vector.
• amount (float) – Weighting value(between 0.0 and 1.0).

Returns:

The result of linear interpolation of the specified vectors.

void Lerp(ref Vector4 value1, ref Vector4 value2, float amount, ref Vector4 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector4) –
• (ref) value2 (Microsoft.Xna.Framework.Vector4) –
• amount (float) –
• (ref) result (Microsoft.Xna.Framework.Vector4) –

Vector4 LerpPrecise(Vector4 value1, Vector4 value2, float amount)

Creates a new T:Microsoft.Xna.Framework.Vector4 that contains linear interpolation of the specified vectors. Uses M:Microsoft.Xna.Framework.MathHelper.LerpPrecise(System.Single,System.Single,System.Single) on MathHelper for the interpolation. Less efficient but more precise compared to M:Microsoft.Xna.Framework.Vector4.Lerp(Microsoft.Xna.Framework.Vector4,Microsoft.Xna.Framework.Vector4,System.Single). See remarks section of M:Microsoft.Xna.Framework.MathHelper.LerpPrecise(System.Single,System.Single,System.Single) on MathHelper for more info.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector4) – The first vector.
• value2 (Microsoft.Xna.Framework.Vector4) – The second vector.
• amount (float) – Weighting value(between 0.0 and 1.0).

Returns:

The result of linear interpolation of the specified vectors.

void LerpPrecise(ref Vector4 value1, ref Vector4 value2, float amount, ref Vector4 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector4) –
• (ref) value2 (Microsoft.Xna.Framework.Vector4) –
• amount (float) –
• (ref) result (Microsoft.Xna.Framework.Vector4) –

Vector4 Max(Vector4 value1, Vector4 value2)

Creates a new T:Microsoft.Xna.Framework.Vector4 that contains a maximal values from the two vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector4) – The first vector.
• value2 (Microsoft.Xna.Framework.Vector4) – The second vector.

Returns:

The T:Microsoft.Xna.Framework.Vector4 with maximal values from the two vectors.

void Max(ref Vector4 value1, ref Vector4 value2, ref Vector4 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector4) –
• (ref) value2 (Microsoft.Xna.Framework.Vector4) –
• (ref) result (Microsoft.Xna.Framework.Vector4) –

Vector4 Min(Vector4 value1, Vector4 value2)

Creates a new T:Microsoft.Xna.Framework.Vector4 that contains a minimal values from the two vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector4) – The first vector.
• value2 (Microsoft.Xna.Framework.Vector4) – The second vector.

Returns:

The T:Microsoft.Xna.Framework.Vector4 with minimal values from the two vectors.

void Min(ref Vector4 value1, ref Vector4 value2, ref Vector4 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector4) –
• (ref) value2 (Microsoft.Xna.Framework.Vector4) –
• (ref) result (Microsoft.Xna.Framework.Vector4) –

Vector4 Multiply(Vector4 value1, Vector4 value2)

Creates a new T:Microsoft.Xna.Framework.Vector4 that contains a multiplication of two vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector4) – Source T:Microsoft.Xna.Framework.Vector4.
• value2 (Microsoft.Xna.Framework.Vector4) – Source T:Microsoft.Xna.Framework.Vector4.

Returns:

The result of the vector multiplication.

Vector4 Multiply(Vector4 value1, float scaleFactor)

Creates a new T:Microsoft.Xna.Framework.Vector4 that contains a multiplication of T:Microsoft.Xna.Framework.Vector4 and a scalar.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector4) – Source T:Microsoft.Xna.Framework.Vector4.
• scaleFactor (float) – Scalar value.

Returns:

The result of the vector multiplication with a scalar.

void Multiply(ref Vector4 value1, float scaleFactor, ref Vector4 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector4) –
• scaleFactor (float) –
• (ref) result (Microsoft.Xna.Framework.Vector4) –

void Multiply(ref Vector4 value1, ref Vector4 value2, ref Vector4 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector4) –
• (ref) value2 (Microsoft.Xna.Framework.Vector4) –
• (ref) result (Microsoft.Xna.Framework.Vector4) –

Vector4 Negate(Vector4 value)

Creates a new T:Microsoft.Xna.Framework.Vector4 that contains the specified vector inversion.

Parameters:

• value (Microsoft.Xna.Framework.Vector4) – Source T:Microsoft.Xna.Framework.Vector4.

Returns:

The result of the vector inversion.

void Negate(ref Vector4 value, ref Vector4 result)

Parameters:

• (ref) value (Microsoft.Xna.Framework.Vector4) –
• (ref) result (Microsoft.Xna.Framework.Vector4) –

void Normalize()

Turns this T:Microsoft.Xna.Framework.Vector4 to a unit vector with the same direction.

Vector4 Normalize(Vector4 value)

Creates a new T:Microsoft.Xna.Framework.Vector4 that contains a normalized values from another vector.

Parameters:

• value (Microsoft.Xna.Framework.Vector4) – Source T:Microsoft.Xna.Framework.Vector4.

Returns:

Unit vector.

void Normalize(ref Vector4 value, ref Vector4 result)

Parameters:

• (ref) value (Microsoft.Xna.Framework.Vector4) –
• (ref) result (Microsoft.Xna.Framework.Vector4) –

Vector4 SmoothStep(Vector4 value1, Vector4 value2, float amount)

Creates a new T:Microsoft.Xna.Framework.Vector4 that contains cubic interpolation of the specified vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector4) – Source T:Microsoft.Xna.Framework.Vector4.
• value2 (Microsoft.Xna.Framework.Vector4) – Source T:Microsoft.Xna.Framework.Vector4.
• amount (float) – Weighting value.

Returns:

Cubic interpolation of the specified vectors.

void SmoothStep(ref Vector4 value1, ref Vector4 value2, float amount, ref Vector4 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector4) –
• (ref) value2 (Microsoft.Xna.Framework.Vector4) –
• amount (float) –
• (ref) result (Microsoft.Xna.Framework.Vector4) –

Vector4 Subtract(Vector4 value1, Vector4 value2)

Creates a new T:Microsoft.Xna.Framework.Vector4 that contains subtraction of on T:Microsoft.Xna.Framework.Vector4 from a another.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector4) – Source T:Microsoft.Xna.Framework.Vector4.
• value2 (Microsoft.Xna.Framework.Vector4) – Source T:Microsoft.Xna.Framework.Vector4.

Returns:

The result of the vector subtraction.

void Subtract(ref Vector4 value1, ref Vector4 value2, ref Vector4 result)

Parameters:

• (ref) value1 (Microsoft.Xna.Framework.Vector4) –
• (ref) value2 (Microsoft.Xna.Framework.Vector4) –
• (ref) result (Microsoft.Xna.Framework.Vector4) –

Vector4 Transform(Vector2 value, Matrix matrix)

Creates a new T:Microsoft.Xna.Framework.Vector4 that contains a transformation of 2d-vector by the specified T:Microsoft.Xna.Framework.Matrix.

Parameters:

• value (Microsoft.Xna.Framework.Vector2) – Source T:Microsoft.Xna.Framework.Vector2.
• matrix (Microsoft.Xna.Framework.Matrix) – The transformation T:Microsoft.Xna.Framework.Matrix.

Returns:

Transformed T:Microsoft.Xna.Framework.Vector4.

Vector4 Transform(Vector2 value, Quaternion rotation)

Creates a new T:Microsoft.Xna.Framework.Vector4 that contains a transformation of 2d-vector by the specified T:Microsoft.Xna.Framework.Quaternion.

Parameters:

• value (Microsoft.Xna.Framework.Vector2) – Source T:Microsoft.Xna.Framework.Vector2.
• rotation (Microsoft.Xna.Framework.Quaternion) – The T:Microsoft.Xna.Framework.Quaternion which contains rotation transformation.

Returns:

Transformed T:Microsoft.Xna.Framework.Vector4.

Vector4 Transform(Vector3 value, Matrix matrix)

Creates a new T:Microsoft.Xna.Framework.Vector4 that contains a transformation of 3d-vector by the specified T:Microsoft.Xna.Framework.Matrix.

Parameters:

• value (Microsoft.Xna.Framework.Vector3) – Source T:Microsoft.Xna.Framework.Vector3.
• matrix (Microsoft.Xna.Framework.Matrix) – The transformation T:Microsoft.Xna.Framework.Matrix.

Returns:

Transformed T:Microsoft.Xna.Framework.Vector4.

Vector4 Transform(Vector3 value, Quaternion rotation)

Creates a new T:Microsoft.Xna.Framework.Vector4 that contains a transformation of 3d-vector by the specified T:Microsoft.Xna.Framework.Quaternion.

Parameters:

• value (Microsoft.Xna.Framework.Vector3) – Source T:Microsoft.Xna.Framework.Vector3.
• rotation (Microsoft.Xna.Framework.Quaternion) – The T:Microsoft.Xna.Framework.Quaternion which contains rotation transformation.

Returns:

Transformed T:Microsoft.Xna.Framework.Vector4.

Vector4 Transform(Vector4 value, Matrix matrix)

Creates a new T:Microsoft.Xna.Framework.Vector4 that contains a transformation of 4d-vector by the specified T:Microsoft.Xna.Framework.Matrix.

Parameters:

• value (Microsoft.Xna.Framework.Vector4) – Source T:Microsoft.Xna.Framework.Vector4.
• matrix (Microsoft.Xna.Framework.Matrix) – The transformation T:Microsoft.Xna.Framework.Matrix.

Returns:

Transformed T:Microsoft.Xna.Framework.Vector4.

Vector4 Transform(Vector4 value, Quaternion rotation)

Creates a new T:Microsoft.Xna.Framework.Vector4 that contains a transformation of 4d-vector by the specified T:Microsoft.Xna.Framework.Quaternion.

Parameters:

• value (Microsoft.Xna.Framework.Vector4) – Source T:Microsoft.Xna.Framework.Vector4.
• rotation (Microsoft.Xna.Framework.Quaternion) – The T:Microsoft.Xna.Framework.Quaternion which contains rotation transformation.

Returns:

Transformed T:Microsoft.Xna.Framework.Vector4.

void Transform(ref Vector2 value, ref Matrix matrix, ref Vector4 result)

Parameters:

• (ref) value (Microsoft.Xna.Framework.Vector2) –
• (ref) matrix (Microsoft.Xna.Framework.Matrix) –
• (ref) result (Microsoft.Xna.Framework.Vector4) –

void Transform(ref Vector2 value, ref Quaternion rotation, ref Vector4 result)

Parameters:

• (ref) value (Microsoft.Xna.Framework.Vector2) –
• (ref) rotation (Microsoft.Xna.Framework.Quaternion) –
• (ref) result (Microsoft.Xna.Framework.Vector4) –

void Transform(ref Vector3 value, ref Matrix matrix, ref Vector4 result)

Parameters:

• (ref) value (Microsoft.Xna.Framework.Vector3) –
• (ref) matrix (Microsoft.Xna.Framework.Matrix) –
• (ref) result (Microsoft.Xna.Framework.Vector4) –

void Transform(ref Vector3 value, ref Quaternion rotation, ref Vector4 result)

Parameters:

• (ref) value (Microsoft.Xna.Framework.Vector3) –
• (ref) rotation (Microsoft.Xna.Framework.Quaternion) –
• (ref) result (Microsoft.Xna.Framework.Vector4) –

void Transform(ref Vector4 value, ref Matrix matrix, ref Vector4 result)

Parameters:

• (ref) value (Microsoft.Xna.Framework.Vector4) –
• (ref) matrix (Microsoft.Xna.Framework.Matrix) –
• (ref) result (Microsoft.Xna.Framework.Vector4) –

void Transform(ref Vector4 value, ref Quaternion rotation, ref Vector4 result)

Parameters:

• (ref) value (Microsoft.Xna.Framework.Vector4) –
• (ref) rotation (Microsoft.Xna.Framework.Quaternion) –
• (ref) result (Microsoft.Xna.Framework.Vector4) –

void Transform(Microsoft.Xna.Framework.Vector4[] sourceArray, int sourceIndex, ref Matrix matrix, Microsoft.Xna.Framework.Vector4[] destinationArray, int destinationIndex, int length)

Parameters:

• sourceArray (Microsoft.Xna.Framework.Vector4[]) –
• sourceIndex (int) –
• (ref) matrix (Microsoft.Xna.Framework.Matrix) –
• destinationArray (Microsoft.Xna.Framework.Vector4[]) –
• destinationIndex (int) –
• length (int) –

void Transform(Microsoft.Xna.Framework.Vector4[] sourceArray, int sourceIndex, ref Quaternion rotation, Microsoft.Xna.Framework.Vector4[] destinationArray, int destinationIndex, int length)

Parameters:

• sourceArray (Microsoft.Xna.Framework.Vector4[]) –
• sourceIndex (int) –
• (ref) rotation (Microsoft.Xna.Framework.Quaternion) –
• destinationArray (Microsoft.Xna.Framework.Vector4[]) –
• destinationIndex (int) –
• length (int) –

void Transform(Microsoft.Xna.Framework.Vector4[] sourceArray, ref Matrix matrix, Microsoft.Xna.Framework.Vector4[] destinationArray)

Parameters:

• sourceArray (Microsoft.Xna.Framework.Vector4[]) –
• (ref) matrix (Microsoft.Xna.Framework.Matrix) –
• destinationArray (Microsoft.Xna.Framework.Vector4[]) –

void Transform(Microsoft.Xna.Framework.Vector4[] sourceArray, ref Quaternion rotation, Microsoft.Xna.Framework.Vector4[] destinationArray)

Parameters:

• sourceArray (Microsoft.Xna.Framework.Vector4[]) –
• (ref) rotation (Microsoft.Xna.Framework.Quaternion) –
• destinationArray (Microsoft.Xna.Framework.Vector4[]) –

string ToString()

Returns a T:System.String representation of this T:Microsoft.Xna.Framework.Vector4 in the format: {X:[F:Microsoft.Xna.Framework.Vector4.X] Y:[F:Microsoft.Xna.Framework.Vector4.Y] Z:[F:Microsoft.Xna.Framework.Vector4.Z] W:[F:Microsoft.Xna.Framework.Vector4.W]}

Returns:A T:System.String representation of this T:Microsoft.Xna.Framework.Vector4.

Vector4 op_UnaryNegation(Vector4 value)

Inverts values in the specified T:Microsoft.Xna.Framework.Vector4.

Parameters:

• value (Microsoft.Xna.Framework.Vector4) – Source T:Microsoft.Xna.Framework.Vector4 on the right of the sub sign.

Returns:

Result of the inversion.

bool op_Equality(Vector4 value1, Vector4 value2)

Compares whether two T:Microsoft.Xna.Framework.Vector4 instances are equal.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector4) – T:Microsoft.Xna.Framework.Vector4 instance on the left of the equal sign.
• value2 (Microsoft.Xna.Framework.Vector4) – T:Microsoft.Xna.Framework.Vector4 instance on the right of the equal sign.

Returns:

true if the instances are equal; false otherwise.

bool op_Inequality(Vector4 value1, Vector4 value2)

Compares whether two T:Microsoft.Xna.Framework.Vector4 instances are not equal.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector4) – T:Microsoft.Xna.Framework.Vector4 instance on the left of the not equal sign.
• value2 (Microsoft.Xna.Framework.Vector4) – T:Microsoft.Xna.Framework.Vector4 instance on the right of the not equal sign.

Returns:

true if the instances are not equal; false otherwise.

Vector4 op_Addition(Vector4 value1, Vector4 value2)

Adds two vectors.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector4) – Source T:Microsoft.Xna.Framework.Vector4 on the left of the add sign.
• value2 (Microsoft.Xna.Framework.Vector4) – Source T:Microsoft.Xna.Framework.Vector4 on the right of the add sign.

Returns:

Sum of the vectors.

Vector4 op_Subtraction(Vector4 value1, Vector4 value2)

Subtracts a T:Microsoft.Xna.Framework.Vector4 from a T:Microsoft.Xna.Framework.Vector4.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector4) – Source T:Microsoft.Xna.Framework.Vector4 on the left of the sub sign.
• value2 (Microsoft.Xna.Framework.Vector4) – Source T:Microsoft.Xna.Framework.Vector4 on the right of the sub sign.

Returns:

Result of the vector subtraction.

Vector4 op_Multiply(Vector4 value1, Vector4 value2)

Multiplies the components of two vectors by each other.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector4) – Source T:Microsoft.Xna.Framework.Vector4 on the left of the mul sign.
• value2 (Microsoft.Xna.Framework.Vector4) – Source T:Microsoft.Xna.Framework.Vector4 on the right of the mul sign.

Returns:

Result of the vector multiplication.

Vector4 op_Multiply(Vector4 value, float scaleFactor)

Multiplies the components of vector by a scalar.

Parameters:

• value (Microsoft.Xna.Framework.Vector4) – Source T:Microsoft.Xna.Framework.Vector4 on the left of the mul sign.
• scaleFactor (float) – Scalar value on the right of the mul sign.

Returns:

Result of the vector multiplication with a scalar.

Vector4 op_Multiply(float scaleFactor, Vector4 value)

Multiplies the components of vector by a scalar.

Parameters:

• scaleFactor (float) – Scalar value on the left of the mul sign.
• value (Microsoft.Xna.Framework.Vector4) – Source T:Microsoft.Xna.Framework.Vector4 on the right of the mul sign.

Returns:

Result of the vector multiplication with a scalar.

Vector4 op_Division(Vector4 value1, Vector4 value2)

Divides the components of a T:Microsoft.Xna.Framework.Vector4 by the components of another T:Microsoft.Xna.Framework.Vector4.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector4) – Source T:Microsoft.Xna.Framework.Vector4 on the left of the div sign.
• value2 (Microsoft.Xna.Framework.Vector4) – Divisor T:Microsoft.Xna.Framework.Vector4 on the right of the div sign.

Returns:

The result of dividing the vectors.

Vector4 op_Division(Vector4 value1, float divider)

Divides the components of a T:Microsoft.Xna.Framework.Vector4 by a scalar.

Parameters:

• value1 (Microsoft.Xna.Framework.Vector4) – Source T:Microsoft.Xna.Framework.Vector4 on the left of the div sign.
• divider (float) – Divisor scalar on the right of the div sign.

Returns:

The result of dividing a vector by a scalar.

Vector4TypeConverter

class Vector4TypeConverter : System.ComponentModel.TypeConverter

public bool CanConvertTo(System.ComponentModel.ITypeDescriptorContext context, System.Type destinationType)

Parameters:

• context (System.ComponentModel.ITypeDescriptorContext) –
• destinationType (System.Type) –

public System.Object ConvertTo(System.ComponentModel.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, System.Object value, System.Type destinationType)

Parameters:

• context (System.ComponentModel.ITypeDescriptorContext) –
• culture (System.Globalization.CultureInfo) –
• value (System.Object) –
• destinationType (System.Type) –

public bool CanConvertFrom(System.ComponentModel.ITypeDescriptorContext context, System.Type sourceType)

Parameters:

• context (System.ComponentModel.ITypeDescriptorContext) –
• sourceType (System.Type) –

public System.Object ConvertFrom(System.ComponentModel.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, System.Object value)

Parameters:

• context (System.ComponentModel.ITypeDescriptorContext) –
• culture (System.Globalization.CultureInfo) –
• value (System.Object) –

VertexBuffer

class VertexBuffer : GraphicsResource, System.IDisposable

readonly int VertexCount

readonly VertexDeclaration VertexDeclaration

readonly BufferUsage BufferUsage

void GraphicsDeviceResetting()

The GraphicsDevice is resetting, so GPU resources must be recreated.

public void GetData<T>(int offsetInBytes, Microsoft.Xna.Framework.Graphics.T[] data, int startIndex, int elementCount, int vertexStride)

Type Parameters:  

• T –

Parameters:

• offsetInBytes (int) –
• data (Microsoft.Xna.Framework.Graphics.T[]) –
• startIndex (int) –
• elementCount (int) –
• vertexStride (int) –

public void GetData<T>(Microsoft.Xna.Framework.Graphics.T[] data, int startIndex, int elementCount)

Type Parameters:  

• T –

Parameters:

• data (Microsoft.Xna.Framework.Graphics.T[]) –
• startIndex (int) –
• elementCount (int) –

public void GetData<T>(Microsoft.Xna.Framework.Graphics.T[] data)

Type Parameters:  

• T –

Parameters:

• data (Microsoft.Xna.Framework.Graphics.T[]) –

public void SetData<T>(int offsetInBytes, Microsoft.Xna.Framework.Graphics.T[] data, int startIndex, int elementCount, int vertexStride)

Type Parameters:  

• T –

Parameters:

• offsetInBytes (int) –
• data (Microsoft.Xna.Framework.Graphics.T[]) –
• startIndex (int) –
• elementCount (int) –
• vertexStride (int) –

public void SetData<T>(Microsoft.Xna.Framework.Graphics.T[] data, int startIndex, int elementCount)

Type Parameters:  

• T –

Parameters:

• data (Microsoft.Xna.Framework.Graphics.T[]) –
• startIndex (int) –
• elementCount (int) –

public void SetData<T>(Microsoft.Xna.Framework.Graphics.T[] data)

Type Parameters:  

• T –

Parameters:

• data (Microsoft.Xna.Framework.Graphics.T[]) –

SharpDX.Direct3D11.Buffer get_Buffer()

VertexBufferBinding

struct VertexBufferBinding : System.ValueType

Defines how a vertex buffer is bound to the graphics device for rendering.

readonly VertexBuffer VertexBuffer

Gets the vertex buffer.

Value:The vertex buffer.

readonly int VertexOffset

Gets the index of the first vertex in the vertex buffer to use.

Value:The index of the first vertex in the vertex buffer to use.

readonly int InstanceFrequency

Gets the number of instances to draw using the same per-instance data before advancing in the buffer by one element.

Value:The number of instances to draw using the same per-instance data before advancing in the buffer by one element. This value must be 0 for an element that contains per-vertex data and greater than 0 for per-instance data.

VertexDeclaration

class VertexDeclaration : GraphicsResource, System.IDisposable, System.IEquatable<VertexDeclaration>

Defines per-vertex data of a vertex buffer.

readonly int VertexStride

Gets the size of a vertex (including padding) in bytes.

Value:The size of a vertex (including padding) in bytes.

VertexDeclaration GetOrCreate(int vertexStride, Microsoft.Xna.Framework.Graphics.VertexElement[] elements)

Parameters:

• vertexStride (int) –
• elements (Microsoft.Xna.Framework.Graphics.VertexElement[]) –

Microsoft.Xna.Framework.Graphics.VertexElement[] get_InternalVertexElements()

VertexDeclaration FromType(System.Type vertexType)

Returns the VertexDeclaration for Type.

Parameters:

• vertexType (System.Type) – A value type which implements the IVertexType interface.

Returns:

The VertexDeclaration.

public Microsoft.Xna.Framework.Graphics.VertexElement[] GetVertexElements()

Gets a copy of the vertex elements.

Returns:A copy of the vertex elements.

public bool Equals(System.Object obj)

Determines whether the specified T:System.Object is equal to this instance.

Parameters:

• obj (System.Object) – The object to compare with the current object.

Returns:

:ref:`` if the specified T:System.Object is equal to this instance;

otherwise, :ref:``.

public bool Equals(VertexDeclaration other)

Determines whether the specified T:Microsoft.Xna.Framework.Graphics.VertexDeclaration is equal to this instance.

Parameters:

• other (Microsoft.Xna.Framework.Graphics.VertexDeclaration) – The object to compare with the current object.

Returns:

:ref:`` if the specified T:Microsoft.Xna.Framework.Graphics.VertexDeclaration is equal to this

instance; otherwise, :ref:``.

public int GetHashCode()

Returns a hash code for this instance.

Returns:A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table.

public bool op_Equality(VertexDeclaration left, VertexDeclaration right)

Compares two T:Microsoft.Xna.Framework.Graphics.VertexElement instances to determine whether they are the same.

Parameters:

• left (Microsoft.Xna.Framework.Graphics.VertexDeclaration) – The first instance.
• right (Microsoft.Xna.Framework.Graphics.VertexDeclaration) – The second instance.

Returns:

:ref:`` if the and are

the same; otherwise, :ref:``.

public bool op_Inequality(VertexDeclaration left, VertexDeclaration right)

Compares two T:Microsoft.Xna.Framework.Graphics.VertexElement instances to determine whether they are different.

Parameters:

• left (Microsoft.Xna.Framework.Graphics.VertexDeclaration) – The first instance.
• right (Microsoft.Xna.Framework.Graphics.VertexDeclaration) – The second instance.

Returns:

:ref:`` if the and are

the different; otherwise, :ref:``.

VertexElement

struct VertexElement : System.ValueType, System.IEquatable<VertexElement>

Defines a single element in a vertex.

int Offset

Gets or sets the offset in bytes from the beginning of the stream to the vertex element.

Value:The offset in bytes.

VertexElementFormat VertexElementFormat

Gets or sets the data format.

Value:The data format.

VertexElementUsage VertexElementUsage

Gets or sets the HLSL semantic of the element in the vertex shader input.

Value:The HLSL semantic of the element in the vertex shader input.

int UsageIndex

Gets or sets the semantic index.

Value:The semantic index, which is required if the semantic is used for more than one vertex element.

int GetHashCode()

Returns a hash code for this instance.

Returns:A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table.

string ToString()

Returns a T:System.String that represents this instance.

Returns:A T:System.String that represents this instance.

bool Equals(System.Object obj)

Determines whether the specified T:System.Object is equal to this instance.

Parameters:

• obj (System.Object) – The object to compare with the current object.

Returns:

:ref:`` if the specified T:System.Object is equal to this instance;

otherwise, :ref:``.

bool Equals(VertexElement other)

Determines whether the specified T:Microsoft.Xna.Framework.Graphics.VertexElement is equal to this instance.

Parameters:

• other (Microsoft.Xna.Framework.Graphics.VertexElement) – The object to compare with the current object.

Returns:

:ref:`` if the specified T:Microsoft.Xna.Framework.Graphics.VertexElement is equal to this

instance; otherwise, :ref:``.

bool op_Equality(VertexElement left, VertexElement right)

Compares two T:Microsoft.Xna.Framework.Graphics.VertexElement instances to determine whether they are the same.

Parameters:

• left (Microsoft.Xna.Framework.Graphics.VertexElement) – The first instance.
• right (Microsoft.Xna.Framework.Graphics.VertexElement) – The second instance.

Returns:

:ref:`` if the and are

the same; otherwise, :ref:``.

bool op_Inequality(VertexElement left, VertexElement right)

Compares two T:Microsoft.Xna.Framework.Graphics.VertexElement instances to determine whether they are different.

Parameters:

• left (Microsoft.Xna.Framework.Graphics.VertexElement) – The first instance.
• right (Microsoft.Xna.Framework.Graphics.VertexElement) – The second instance.

Returns:

:ref:`` if the and are

the different; otherwise, :ref:``.

SharpDX.Direct3D11.InputElement GetInputElement(int slot, int instanceFrequency)

Gets the DirectX T:SharpDX.Direct3D11.InputElement.

Parameters:

• slot (int) – The input resource slot.
• instanceFrequency (int) – The number of instances to draw using the same per-instance data before advancing in the buffer by one element. This value must be 0 for an element that contains per-vertex data.

Returns:

T:SharpDX.Direct3D11.InputElement.

VertexElementFormat

enum VertexElementFormat : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines vertex element formats.

VertexElementFormat Single

Single 32-bit floating point number.

VertexElementFormat Vector2

Two component 32-bit floating point number.

VertexElementFormat Vector3

Three component 32-bit floating point number.

VertexElementFormat Vector4

Four component 32-bit floating point number.

VertexElementFormat Color

Four component, packed unsigned byte, mapped to 0 to 1 range.

VertexElementFormat Byte4

Four component unsigned byte.

VertexElementFormat Short2

Two component signed 16-bit integer.

VertexElementFormat Short4

Four component signed 16-bit integer.

VertexElementFormat NormalizedShort2

Normalized, two component signed 16-bit integer.

VertexElementFormat NormalizedShort4

Normalized, four component signed 16-bit integer.

VertexElementFormat HalfVector2

Two component 16-bit floating point number.

VertexElementFormat HalfVector4

Four component 16-bit floating point number.

VertexElementUsage

enum VertexElementUsage : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Defines usage for vertex elements.

VertexElementUsage Position

Position data.

VertexElementUsage Color

Color data.

VertexElementUsage TextureCoordinate

Texture coordinate data or can be used for user-defined data.

VertexElementUsage Normal

Normal data.

VertexElementUsage Binormal

Binormal data.

VertexElementUsage Tangent

Tangent data.

VertexElementUsage BlendIndices

Blending indices data.

VertexElementUsage BlendWeight

Blending weight data.

VertexElementUsage Depth

Depth data.

VertexElementUsage Fog

Fog data.

VertexElementUsage PointSize

Point size data. Usable for drawing point sprites.

VertexElementUsage Sample

Sampler data for specifies the displacement value to look up.

VertexElementUsage TessellateFactor

Single, positive float value, specifies a tessellation factor used in the tessellation unit to control the rate of tessellation.

VertexPosition

struct VertexPosition : System.ValueType, IVertexType

Vector3 Position

VertexDeclaration VertexDeclaration

int GetHashCode()

string ToString()

bool op_Equality(VertexPosition left, VertexPosition right)

Parameters:

• left (Microsoft.Xna.Framework.Graphics.VertexPosition) –
• right (Microsoft.Xna.Framework.Graphics.VertexPosition) –

bool op_Inequality(VertexPosition left, VertexPosition right)

Parameters:

• left (Microsoft.Xna.Framework.Graphics.VertexPosition) –
• right (Microsoft.Xna.Framework.Graphics.VertexPosition) –

bool Equals(System.Object obj)

Parameters:

• obj (System.Object) –

VertexPositionColor

struct VertexPositionColor : System.ValueType, IVertexType

Vector3 Position

Color Color

VertexDeclaration VertexDeclaration

int GetHashCode()

string ToString()

bool op_Equality(VertexPositionColor left, VertexPositionColor right)

Parameters:

• left (Microsoft.Xna.Framework.Graphics.VertexPositionColor) –
• right (Microsoft.Xna.Framework.Graphics.VertexPositionColor) –

bool op_Inequality(VertexPositionColor left, VertexPositionColor right)

Parameters:

• left (Microsoft.Xna.Framework.Graphics.VertexPositionColor) –
• right (Microsoft.Xna.Framework.Graphics.VertexPositionColor) –

bool Equals(System.Object obj)

Parameters:

• obj (System.Object) –

VertexPositionColorTexture

struct VertexPositionColorTexture : System.ValueType, IVertexType

Vector3 Position

Color Color

Vector2 TextureCoordinate

VertexDeclaration VertexDeclaration

int GetHashCode()

string ToString()

bool op_Equality(VertexPositionColorTexture left, VertexPositionColorTexture right)

Parameters:

• left (Microsoft.Xna.Framework.Graphics.VertexPositionColorTexture) –
• right (Microsoft.Xna.Framework.Graphics.VertexPositionColorTexture) –

bool op_Inequality(VertexPositionColorTexture left, VertexPositionColorTexture right)

Parameters:

• left (Microsoft.Xna.Framework.Graphics.VertexPositionColorTexture) –
• right (Microsoft.Xna.Framework.Graphics.VertexPositionColorTexture) –

bool Equals(System.Object obj)

Parameters:

• obj (System.Object) –

VertexPositionNormalTexture

struct VertexPositionNormalTexture : System.ValueType, IVertexType

Vector3 Position

Vector3 Normal

Vector2 TextureCoordinate

VertexDeclaration VertexDeclaration

int GetHashCode()

string ToString()

bool op_Equality(VertexPositionNormalTexture left, VertexPositionNormalTexture right)

Parameters:

• left (Microsoft.Xna.Framework.Graphics.VertexPositionNormalTexture) –
• right (Microsoft.Xna.Framework.Graphics.VertexPositionNormalTexture) –

bool op_Inequality(VertexPositionNormalTexture left, VertexPositionNormalTexture right)

Parameters:

• left (Microsoft.Xna.Framework.Graphics.VertexPositionNormalTexture) –
• right (Microsoft.Xna.Framework.Graphics.VertexPositionNormalTexture) –

bool Equals(System.Object obj)

Parameters:

• obj (System.Object) –

VertexPositionTexture

struct VertexPositionTexture : System.ValueType, IVertexType

Vector3 Position

Vector2 TextureCoordinate

VertexDeclaration VertexDeclaration

int GetHashCode()

string ToString()

bool op_Equality(VertexPositionTexture left, VertexPositionTexture right)

Parameters:

• left (Microsoft.Xna.Framework.Graphics.VertexPositionTexture) –
• right (Microsoft.Xna.Framework.Graphics.VertexPositionTexture) –

bool op_Inequality(VertexPositionTexture left, VertexPositionTexture right)

Parameters:

• left (Microsoft.Xna.Framework.Graphics.VertexPositionTexture) –
• right (Microsoft.Xna.Framework.Graphics.VertexPositionTexture) –

bool Equals(System.Object obj)

Parameters:

• obj (System.Object) –

Video

class Video : System.Object, System.IDisposable

Represents a video.

readonly string FileName

I actually think this is a file PATH...

readonly System.TimeSpan Duration

Gets the duration of the Video.

readonly float FramesPerSecond

Gets the frame rate of this video.

readonly int Height

Gets the height of this video, in pixels.

readonly VideoSoundtrackType VideoSoundtrackType

Gets the VideoSoundtrackType for this video.

readonly int Width

Gets the width of this video, in pixels.

void set_Duration(System.TimeSpan value)

Parameters:

• value (System.TimeSpan) –

void set_FramesPerSecond(float value)

Parameters:

• value (float) –

void set_Height(int value)

Parameters:

• value (int) –

void set_VideoSoundtrackType(VideoSoundtrackType value)

Parameters:

• value (Microsoft.Xna.Framework.Media.VideoSoundtrackType) –

void set_Width(int value)

Parameters:

• value (int) –

public void Dispose()

SharpDX.MediaFoundation.Topology get_Topology()

Microsoft.Xna.Framework.Media.VideoSampleGrabber get_SampleGrabber()

VideoPlayer

class VideoPlayer : System.Object, System.IDisposable

readonly bool IsDisposed

Gets a value that indicates whether the object is disposed.

bool IsLooped

Gets a value that indicates whether the player is playing video in a loop.

bool IsMuted

Gets or sets the muted setting for the video player.

readonly System.TimeSpan PlayPosition

Gets the play position within the currently playing video.

readonly MediaState State

Gets the media playback state, MediaState.

readonly Video Video

Gets the Video that is currently playing.

float Volume

Video player volume, from 0.0f (silence) to 1.0f (full volume relative to the current device volume).

public Texture2D GetTexture()

Retrieves a Texture2D containing the current frame of video being played.

Returns:The current frame of video.

public void Pause()

Pauses the currently playing video.

public void Play(Video video)

Plays a Video.

Parameters:

• video (Microsoft.Xna.Framework.Media.Video) – Video to play.

public void Resume()

Resumes a paused video.

public void Stop()

Stops playing a video.

public void Dispose()

Immediately releases the unmanaged resources used by this object.

VideoSoundtrackType

enum VideoSoundtrackType : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Type of sounds in a video

VideoSoundtrackType Music

This video contains only music.

VideoSoundtrackType Dialog

This video contains only dialog.

VideoSoundtrackType MusicAndDialog

This video contains music and dialog.

Viewport

struct Viewport : System.ValueType

Describes the view bounds for render-target surface.

int Height

The height of the bounds in pixels.

float MaxDepth

The upper limit of depth of this viewport.

float MinDepth

The lower limit of depth of this viewport.

int Width

The width of the bounds in pixels.

int Y

The y coordinate of the beginning of this viewport.

int X

The x coordinate of the beginning of this viewport.

readonly float AspectRatio

Gets the aspect ratio of this T:Microsoft.Xna.Framework.Graphics.Viewport, which is width / height.

Rectangle Bounds

Gets or sets a boundary of this T:Microsoft.Xna.Framework.Graphics.Viewport.

readonly Rectangle TitleSafeArea

Returns the subset of the viewport that is guaranteed to be visible on a lower quality display.

Vector3 Project(Vector3 source, Matrix projection, Matrix view, Matrix world)

Projects a T:Microsoft.Xna.Framework.Vector3 from world space into screen space.

Parameters:

• source (Microsoft.Xna.Framework.Vector3) – The T:Microsoft.Xna.Framework.Vector3 to project.
• projection (Microsoft.Xna.Framework.Matrix) – The projection T:Microsoft.Xna.Framework.Matrix.
• view (Microsoft.Xna.Framework.Matrix) – The view T:Microsoft.Xna.Framework.Matrix.
• world (Microsoft.Xna.Framework.Matrix) – The world T:Microsoft.Xna.Framework.Matrix.

Returns:

Vector3 Unproject(Vector3 source, Matrix projection, Matrix view, Matrix world)

Unprojects a T:Microsoft.Xna.Framework.Vector3 from screen space into world space.

Parameters:

• source (Microsoft.Xna.Framework.Vector3) – The T:Microsoft.Xna.Framework.Vector3 to unproject.
• projection (Microsoft.Xna.Framework.Matrix) – The projection T:Microsoft.Xna.Framework.Matrix.
• view (Microsoft.Xna.Framework.Matrix) – The view T:Microsoft.Xna.Framework.Matrix.
• world (Microsoft.Xna.Framework.Matrix) – The world T:Microsoft.Xna.Framework.Matrix.

Returns:

string ToString()

Returns a T:System.String representation of this T:Microsoft.Xna.Framework.Graphics.Viewport in the format: {X:[P:Microsoft.Xna.Framework.Graphics.Viewport.X] Y:[P:Microsoft.Xna.Framework.Graphics.Viewport.Y] Width:[P:Microsoft.Xna.Framework.Graphics.Viewport.Width] Height:[P:Microsoft.Xna.Framework.Graphics.Viewport.Height] MinDepth:[P:Microsoft.Xna.Framework.Graphics.Viewport.MinDepth] MaxDepth:[P:Microsoft.Xna.Framework.Graphics.Viewport.MaxDepth]}

Returns:A T:System.String representation of this T:Microsoft.Xna.Framework.Graphics.Viewport.

WaveBank

class WaveBank : System.Object, System.IDisposable

Represents a collection of wave files.

readonly bool IsInUse

readonly bool IsPrepared

readonly bool IsDisposed

Is true if the WaveBank has been disposed.

SoundEffect GetSoundEffect(int trackIndex)

Parameters:

• trackIndex (int) –

public void add_Disposing(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void remove_Disposing(System.EventHandler<EventArgs> value)

Parameters:

• value (System.EventHandler<EventArgs>) –

public void Dispose()

Disposes the WaveBank.

ZlibStream

class ZlibStream : System.IO.Stream, System.IDisposable

Represents a Zlib stream for compression or decompression.

FlushType FlushMode

This property sets the flush behavior on the stream. Sorry, though, not sure exactly how to describe all the various settings.

int BufferSize

The size of the working buffer for the compression codec.

readonly long TotalIn

Returns the total number of bytes input so far.

readonly long TotalOut

Returns the total number of bytes output so far.

readonly bool CanRead

Indicates whether the stream can be read.

readonly bool CanSeek

Indicates whether the stream supports Seek operations.

readonly bool CanWrite

Indicates whether the stream can be written.

readonly long Length

Reading this property always throws a T:System.NotSupportedException.

long Position

The position of the stream pointer.

public void Flush()

Flush the stream.

public int Read(System.Byte[] buffer, int offset, int count)

Read data from the stream.

Parameters:

• buffer (System.Byte[]) – The buffer into which the read data should be placed.
• offset (int) – the offset within that data array to put the first byte read.
• count (int) – the number of bytes to read.

Returns:

the number of bytes read

public long Seek(long offset, System.IO.SeekOrigin origin)

Calling this method always throws a T:System.NotSupportedException.

Parameters:

• offset (long) – The offset to seek to.... IF THIS METHOD ACTUALLY DID ANYTHING.
• origin (System.IO.SeekOrigin) – The reference specifying how to apply the offset.... IF THIS METHOD ACTUALLY DID ANYTHING.

Returns:

nothing. This method always throws.

public void SetLength(long value)

Calling this method always throws a T:System.NotSupportedException.

Parameters:

• value (long) – The new value for the stream length.... IF THIS METHOD ACTUALLY DID ANYTHING.

public void Write(System.Byte[] buffer, int offset, int count)

Write data to the stream.

Parameters:

• buffer (System.Byte[]) – The buffer holding data to write to the stream.
• offset (int) – the offset within that data array to find the first byte to write.
• count (int) – the number of bytes to write.

public System.Byte[] CompressString(string s)

Compress a string into a byte array using ZLIB.

Parameters:

• s (string) – A string to compress. The string will first be encoded using UTF8, then compressed.

Returns:

The string in compressed form

public System.Byte[] CompressBuffer(System.Byte[] b)

Compress a byte array into a new byte array using ZLIB.

Parameters:

• b (System.Byte[]) – A buffer to compress.

Returns:

The data in compressed form

public string UncompressString(System.Byte[] compressed)

Uncompress a ZLIB-compressed byte array into a single string.

Parameters:

• compressed (System.Byte[]) – A buffer containing ZLIB-compressed data.

Returns:

The uncompressed string

public System.Byte[] UncompressBuffer(System.Byte[] compressed)

Uncompress a ZLIB-compressed byte array into a byte array.

Parameters:

• compressed (System.Byte[]) – A buffer containing ZLIB-compressed data.

Returns:

The data in uncompressed form

MonoGame Framework (Content Pipeline)

The MonoGame Content Pipeline is used on desktop platforms to compile content for all platforms (including mobile devices).

Warning

These APIs are only available when targeting a desktop platform (Windows, Mac OS X or Linux).

ABCFloat

struct ABCFloat : System.ValueType

float A

float B

float C

AlphaTestMaterialContent

class AlphaTestMaterialContent : MaterialContent

string AlphaKey

string AlphaFunctionKey

string DiffuseColorKey

string ReferenceAlphaKey

string TextureKey

string VertexColorEnabledKey

System.Nullable<Single> Alpha

System.Nullable<CompareFunction> AlphaFunction

System.Nullable<Vector3> DiffuseColor

System.Nullable<Int32> ReferenceAlpha

Microsoft.Xna.Framework.Content.Pipeline.ExternalReference<TextureContent> Texture

System.Nullable<Boolean> VertexColorEnabled

AnimationChannel

class AnimationChannel : System.Object, System.Collections.Generic.ICollection<AnimationKeyframe>, System.Collections.Generic.IEnumerable<AnimationKeyframe>, System.Collections.IEnumerable

Provides methods and properties for maintaining an animation channel. An animation channel is a collection of keyframes describing the movement of a single bone or rigid object.

readonly int Count

Gets the number of keyframes in the collection.

readonly AnimationKeyframe Item

public int Add(AnimationKeyframe item)

Adds a new keyframe to the collection, automatically sorting the contents according to keyframe times.

Parameters:

• item (Microsoft.Xna.Framework.Content.Pipeline.Graphics.AnimationKeyframe) – Keyframe to be added to the channel.

Returns:

Index of the new keyframe.

public void Clear()

Removes all keyframes from the collection.

public bool Contains(AnimationKeyframe item)

Searches the collection for the specified keyframe.

Parameters:

• item (Microsoft.Xna.Framework.Content.Pipeline.Graphics.AnimationKeyframe) – Keyframe being searched for.

Returns:

true if the keyframe exists; false otherwise.

public int IndexOf(AnimationKeyframe item)

Determines the index for the specified keyframe.

Parameters:

• item (Microsoft.Xna.Framework.Content.Pipeline.Graphics.AnimationKeyframe) – Identity of a keyframe.

Returns:

Index of the specified keyframe.

public bool Remove(AnimationKeyframe item)

Removes the specified keyframe from the collection.

Parameters:

• item (Microsoft.Xna.Framework.Content.Pipeline.Graphics.AnimationKeyframe) – Keyframe being removed.

Returns:

true if the keyframe was removed; false otherwise.

public void RemoveAt(int index)

Removes the keyframe at the specified index position.

Parameters:

• index (int) – Index of the keyframe being removed.

public System.Collections.Generic.IEnumerator<AnimationKeyframe> GetEnumerator()

Returns an enumerator that iterates through the keyframes.

Returns:Enumerator for the keyframe collection.

AnimationChannelDictionary

class AnimationChannelDictionary : Microsoft.Xna.Framework.Content.Pipeline.NamedValueDictionary<AnimationChannel>, System.Collections.Generic.IDictionary<String, AnimationChannel>, System.Collections.Generic.ICollection<KeyValuePair`2>, System.Collections.Generic.IEnumerable<KeyValuePair`2>, System.Collections.IEnumerable

Collection of animation data channels, one per bone or rigid object.

AnimationContent

class AnimationContent : ContentItem

Provides properties for maintaining an animation.

readonly AnimationChannelDictionary Channels

Gets the collection of animation data channels. Each channel describes the movement of a single bone or rigid object.

System.TimeSpan Duration

Gets or sets the total length of the animation.

AnimationContentDictionary

class AnimationContentDictionary : Microsoft.Xna.Framework.Content.Pipeline.NamedValueDictionary<AnimationContent>, System.Collections.Generic.IDictionary<String, AnimationContent>, System.Collections.Generic.ICollection<KeyValuePair`2>, System.Collections.Generic.IEnumerable<KeyValuePair`2>, System.Collections.IEnumerable

Collection of named animations.

AnimationKeyframe

class AnimationKeyframe : System.Object, System.IComparable<AnimationKeyframe>

Provides methods and properties for managing a keyframe. A keyframe describes the position of an animation channel at a single point in time.

readonly System.TimeSpan Time

Gets the time offset from the start of the animation to the position described by this keyframe.

Matrix Transform

Gets or sets the position described by this keyframe.

public int CompareTo(AnimationKeyframe other)

Compares this instance of a keyframe to another.

Parameters:

• other (Microsoft.Xna.Framework.Content.Pipeline.Graphics.AnimationKeyframe) – Keyframe being compared to.

Returns:

Indication of their relative values.

AtcBitmapContent

class AtcBitmapContent : BitmapContent

public System.Byte[] GetPixelData()

public void SetPixelData(System.Byte[] sourceData)

Parameters:

• sourceData (System.Byte[]) –

AtcExplicitBitmapContent

class AtcExplicitBitmapContent : AtcBitmapContent

public bool TryGetFormat(ref SurfaceFormat format)

Parameters:

• (ref) format (Microsoft.Xna.Framework.Graphics.SurfaceFormat) –

public string ToString()

Returns a string description of the bitmap.

Returns:Description of the bitmap.

AtcInterpolatedBitmapContent

class AtcInterpolatedBitmapContent : AtcBitmapContent

public bool TryGetFormat(ref SurfaceFormat format)

Parameters:

• (ref) format (Microsoft.Xna.Framework.Graphics.SurfaceFormat) –

public string ToString()

Returns a string description of the bitmap.

Returns:Description of the bitmap.

AudioContent

class AudioContent : ContentItem, System.IDisposable

Encapsulates and provides operations, such as format conversions, on the source audio. This type is produced by the audio importers and used by audio processors to produce compiled audio assets.

readonly string FileName

The name of the original source audio file.

readonly AudioFileType FileType

The type of the original source audio file.

readonly System.Collections.ObjectModel.ReadOnlyCollection<Byte> Data

The current raw audio data without header information.

readonly System.TimeSpan Duration

The duration of the audio data.

readonly AudioFormat Format

The current format of the audio data.

readonly int LoopLength

The current loop length in samples.

readonly int LoopStart

The current loop start location in samples.

public void ConvertFormat(ConversionFormat formatType, ConversionQuality quality, string saveToFile)

Transcodes the source audio to the target format and quality.

Parameters:

• formatType (Microsoft.Xna.Framework.Content.Pipeline.Audio.ConversionFormat) – Format to convert this audio to.
• quality (Microsoft.Xna.Framework.Content.Pipeline.Audio.ConversionQuality) – Quality of the processed output audio. For streaming formats, it can be one of the following: Low (96 kbps), Medium (128 kbps), Best (192 kbps). For WAV formats, it can be one of the following: Low (11kHz ADPCM), Medium (22kHz ADPCM), Best (44kHz PCM)
• saveToFile (string) – The name of the file that the converted audio should be saved into. This is used for SongContent, where the audio is stored external to the XNB file. If this is null, then the converted audio is stored in the Data property.

public void SetData(System.Byte[] data, AudioFormat format, System.TimeSpan duration, int loopStart, int loopLength)

Parameters:

• data (System.Byte[]) –
• format (Microsoft.Xna.Framework.Content.Pipeline.Audio.AudioFormat) –
• duration (System.TimeSpan) –
• loopStart (int) –
• loopLength (int) –

public void Dispose()

AudioFileType

enum AudioFileType : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Type of the audio file.

AudioFileType Mp3

The MP3 format

AudioFileType Wav

The WAV format

AudioFileType Wma

The WMA format

AudioFileType Ogg

The Ogg format

AudioFormat

class AudioFormat : System.Object

Encapsulates the native audio format (WAVEFORMATEX) information of the audio content.

readonly int AverageBytesPerSecond

Gets the average bytes processed per second.

Value:Average bytes processed per second.

readonly int BitsPerSample

Gets the bit depth of the audio content.

Value:If the audio has not been processed, the source bit depth; otherwise, the bit depth of the new format.

readonly int BlockAlign

Gets the number of bytes per sample block, taking channels into consideration. For example, for 16-bit stereo audio (PCM format), the size of each sample block is 4 bytes.

Value:Number of bytes, per sample block.

readonly int ChannelCount

Gets the number of channels.

Value:If the audio has not been processed, the source channel count; otherwise, the new channel count.

readonly int Format

Gets the format of the audio content.

Value:If the audio has not been processed, the format tag of the source content; otherwise, the new format tag.

readonly System.Collections.ObjectModel.ReadOnlyCollection<Byte> NativeWaveFormat

Gets the raw byte buffer for the format. For non-PCM formats, this buffer contains important format-specific information beyond the basic format information exposed in other properties of the AudioFormat type.

Value:The raw byte buffer represented in a collection.

readonly int SampleRate

Gets the sample rate of the audio content.

Value:If the audio has not been processed, the source sample rate; otherwise, the new sample rate.

AudioProfile

class AudioProfile : System.Object

public AudioProfile ForPlatform(TargetPlatform platform)

Find the profile for this target platform.

Parameters:

• platform (Microsoft.Xna.Framework.Content.Pipeline.TargetPlatform) – The platform target for audio.

Returns:

public abstract bool Supports(TargetPlatform platform)

Returns true if this profile supports audio processing for this platform.

Parameters:

• platform (Microsoft.Xna.Framework.Content.Pipeline.TargetPlatform) –

public abstract ConversionQuality ConvertAudio(TargetPlatform platform, ConversionQuality quality, AudioContent content)

Converts the audio content to work on targeted platform.

Parameters:

• platform (Microsoft.Xna.Framework.Content.Pipeline.TargetPlatform) – The platform to build the audio content for.
• quality (Microsoft.Xna.Framework.Content.Pipeline.Audio.ConversionQuality) – The suggested audio quality level.
• content (Microsoft.Xna.Framework.Content.Pipeline.Audio.AudioContent) – The audio content to convert.

Returns:

The quality used for conversion which could be different from the suggested quality.

public abstract ConversionQuality ConvertStreamingAudio(TargetPlatform platform, ConversionQuality quality, AudioContent content, ref string outputFileName)

Parameters:

• platform (Microsoft.Xna.Framework.Content.Pipeline.TargetPlatform) –
• quality (Microsoft.Xna.Framework.Content.Pipeline.Audio.ConversionQuality) –
• content (Microsoft.Xna.Framework.Content.Pipeline.Audio.AudioContent) –
• (ref) outputFileName (string) –

BasicMaterialContent

class BasicMaterialContent : MaterialContent

string AlphaKey

string DiffuseColorKey

string EmissiveColorKey

string SpecularColorKey

string SpecularPowerKey

string TextureKey

string VertexColorEnabledKey

System.Nullable<Single> Alpha

System.Nullable<Vector3> DiffuseColor

System.Nullable<Vector3> EmissiveColor

System.Nullable<Vector3> SpecularColor

System.Nullable<Single> SpecularPower

Microsoft.Xna.Framework.Content.Pipeline.ExternalReference<TextureContent> Texture

System.Nullable<Boolean> VertexColorEnabled

BitmapContent

class BitmapContent : ContentItem

Provides properties and methods for creating and maintaining a bitmap resource.

readonly int Height

Gets or sets the height of the bitmap, in pixels.

readonly int Width

Gets or sets the width of the bitmap, in pixels.

public void Copy(BitmapContent sourceBitmap, BitmapContent destinationBitmap)

Copies one bitmap into another. The destination bitmap can be in any format and size. If the destination is larger or smaller, the source bitmap is scaled accordingly.

Parameters:

• sourceBitmap (Microsoft.Xna.Framework.Content.Pipeline.Graphics.BitmapContent) – BitmapContent being copied.
• destinationBitmap (Microsoft.Xna.Framework.Content.Pipeline.Graphics.BitmapContent) – BitmapContent being overwritten.

public void Copy(BitmapContent sourceBitmap, Rectangle sourceRegion, BitmapContent destinationBitmap, Rectangle destinationRegion)

Copies one bitmap into another. The destination bitmap can be in any format and size. If the destination is larger or smaller, the source bitmap is scaled accordingly.

Parameters:

• sourceBitmap (Microsoft.Xna.Framework.Content.Pipeline.Graphics.BitmapContent) – BitmapContent being copied.
• sourceRegion (Microsoft.Xna.Framework.Rectangle) – Region of sourceBitmap.
• destinationBitmap (Microsoft.Xna.Framework.Content.Pipeline.Graphics.BitmapContent) – BitmapContent being overwritten.
• destinationRegion (Microsoft.Xna.Framework.Rectangle) – Region of bitmap to be overwritten.

public abstract System.Byte[] GetPixelData()

Reads encoded bitmap content.

Returns:Array containing encoded bitmap data.

public abstract void SetPixelData(System.Byte[] sourceData)

Writes encoded bitmap content.

Parameters:

• sourceData (System.Byte[]) – Array containing encoded bitmap data to be set.

public string ToString()

Returns a string description of the bitmap resource.

Returns:Description of the bitmap.

protected abstract bool TryCopyFrom(BitmapContent sourceBitmap, Rectangle sourceRegion, Rectangle destinationRegion)

Attempts to copy a region from a specified bitmap.

Parameters:

• sourceBitmap (Microsoft.Xna.Framework.Content.Pipeline.Graphics.BitmapContent) – BitmapContent being copied.
• sourceRegion (Microsoft.Xna.Framework.Rectangle) – Location of sourceBitmap.
• destinationRegion (Microsoft.Xna.Framework.Rectangle) – Region of destination bitmap to be overwritten.

Returns:

true if region copy is supported; false otherwise.

protected abstract bool TryCopyTo(BitmapContent destinationBitmap, Rectangle sourceRegion, Rectangle destinationRegion)

Attempts to copy a region of the specified bitmap onto another.

Parameters:

• destinationBitmap (Microsoft.Xna.Framework.Content.Pipeline.Graphics.BitmapContent) – BitmapContent being overwritten.
• sourceRegion (Microsoft.Xna.Framework.Rectangle) – Location of the source bitmap.
• destinationRegion (Microsoft.Xna.Framework.Rectangle) – Region of destination bitmap to be overwritten.

Returns:

true if region copy is supported; false otherwise.

public abstract bool TryGetFormat(ref SurfaceFormat format)

Parameters:

• (ref) format (Microsoft.Xna.Framework.Graphics.SurfaceFormat) –

BoneContent

class BoneContent : NodeContent

Represents an animation skeleton.

BoneWeight

struct BoneWeight : System.ValueType

Provides properties for managing a bone weight.

readonly string BoneName

Gets the name of the bone.

readonly float Weight

Gets the amount of bone influence, ranging from zero to one. The complete set of weights in a BoneWeightCollection should sum to one.

void set_Weight(float value)

Parameters:

• value (float) –

BoneWeightCollection

class BoneWeightCollection : System.Collections.ObjectModel.Collection<BoneWeight>, System.Collections.Generic.IList<BoneWeight>, System.Collections.Generic.ICollection<BoneWeight>, System.Collections.Generic.IEnumerable<BoneWeight>, System.Collections.IEnumerable, System.Collections.IList, System.Collections.ICollection, System.Collections.Generic.IReadOnlyList<BoneWeight>, System.Collections.Generic.IReadOnlyCollection<BoneWeight>

Collection of bone weights of a vertex.

public void NormalizeWeights()

Normalizes the contents of the weights list.

public void NormalizeWeights(int maxWeights)

Normalizes the contents of the bone weights list.

Parameters:

• maxWeights (int) – Maximum number of weights allowed.

CharacterRegion

struct CharacterRegion : System.ValueType

char Start

char End

CharacterRegion Default

System.Collections.Generic.IEnumerable<Char> Characters()

bool Any<T>(System.Collections.Generic.IEnumerable<T> source)

Test if there is an element in this enumeration.

Type Parameters:  

• T – Type of the element

Parameters:

• source (System.Collections.Generic.IEnumerable<T>) – The enumerable source.

Returns:

true if there is an element in this enumeration, false otherwise

System.Collections.Generic.IEnumerable<TResult> SelectMany<TSource, TResult>(System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, IEnumerable`1> selector)

Select elements from an enumeration.

Type Parameters:  

• TSource – The type of the T source.
• TResult – The type of the T result.

Parameters:

• source (System.Collections.Generic.IEnumerable<TSource>) – The source.
• IEnumerable`1> selector (System.Func<TSource,) – The selector.

Returns:

A enumeration of selected values

System.Collections.Generic.IEnumerable<TSource> Distinct<TSource>(System.Collections.Generic.IEnumerable<TSource> source, System.Collections.Generic.IEqualityComparer<TSource> comparer)

Selects distinct elements from an enumeration.

Type Parameters:  

• TSource – The type of the T source.

Parameters:

• source (System.Collections.Generic.IEnumerable<TSource>) – The source.
• comparer (System.Collections.Generic.IEqualityComparer<TSource>) – The comparer.

Returns:

A enumeration of selected values

CharacterRegionTypeConverter

class CharacterRegionTypeConverter : System.ComponentModel.TypeConverter

public bool CanConvertFrom(System.ComponentModel.ITypeDescriptorContext context, System.Type sourceType)

Parameters:

• context (System.ComponentModel.ITypeDescriptorContext) –
• sourceType (System.Type) –

public System.Object ConvertFrom(System.ComponentModel.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, System.Object value)

Parameters:

• context (System.ComponentModel.ITypeDescriptorContext) –
• culture (System.Globalization.CultureInfo) –
• value (System.Object) –

ChildCollection<TParent, TChild>

class ChildCollection<TParent, TChild> : System.Collections.ObjectModel.Collection<TChild>, System.Collections.Generic.IList<TChild>, System.Collections.Generic.ICollection<TChild>, System.Collections.Generic.IEnumerable<TChild>, System.Collections.IEnumerable, System.Collections.IList, System.Collections.ICollection, System.Collections.Generic.IReadOnlyList<TChild>, System.Collections.Generic.IReadOnlyCollection<TChild>

Provides a collection of child objects for a content item.

Links from a child object to its parent are maintained as the collection contents are modified.

Type Parameters:  

• TParent –
• TChild –

protected abstract Microsoft.Xna.Framework.Content.Pipeline.TParent GetParent(Microsoft.Xna.Framework.Content.Pipeline.TChild child)

Parameters:

• child (Microsoft.Xna.Framework.Content.Pipeline.TChild) –

protected abstract void SetParent(Microsoft.Xna.Framework.Content.Pipeline.TChild child, Microsoft.Xna.Framework.Content.Pipeline.TParent parent)

Parameters:

• child (Microsoft.Xna.Framework.Content.Pipeline.TChild) –
• parent (Microsoft.Xna.Framework.Content.Pipeline.TParent) –

CommandLineParser

class CommandLineParser : System.Object

string Title

public bool ParseCommandLine(System.String[] args)

Parameters:

• args (System.String[]) –

CompiledEffectContent

class CompiledEffectContent : ContentItem

Represents a compiled Effect.

public System.Byte[] GetEffectCode()

Retrieves the compiled byte code for this shader.

Returns:The compiled bytecode.

ContentBuildLogger

class ContentBuildLogger : System.Object

Provides methods for reporting informational messages or warnings from content importers and processors. Do not use this class to report errors. Instead, report errors by throwing a PipelineException or InvalidContentException.

string LoggerRootDirectory

Gets or sets the base reference path used when reporting errors during the content build process.

public abstract void LogImportantMessage(string message, System.Object[] messageArgs)

Outputs a high-priority status message from a content importer or processor.

Parameters:

• message (string) – Message being reported.
• messageArgs (System.Object[]) – Arguments for the reported message.

public abstract void LogMessage(string message, System.Object[] messageArgs)

Outputs a low priority status message from a content importer or processor.

Parameters:

• message (string) – Message being reported.
• messageArgs (System.Object[]) – Arguments for the reported message.

public abstract void LogWarning(string helpLink, ContentIdentity contentIdentity, string message, System.Object[] messageArgs)

Outputs a warning message from a content importer or processor.

Parameters:

• helpLink (string) – Link to an existing online help topic containing related information.
• contentIdentity (Microsoft.Xna.Framework.Content.Pipeline.ContentIdentity) – Identity of the content item that generated the message.
• message (string) – Message being reported.
• messageArgs (System.Object[]) – Arguments for the reported message.

public void PopFile()

Outputs a message indicating that a content asset has completed processing.

public void PushFile(string filename)

Outputs a message indicating that a content asset has begun processing. All logger warnings or error exceptions from this time forward to the next PopFile call refer to this file.

Parameters:

• filename (string) – Name of the file containing future messages.

public void Indent()

public void Unindent()

ContentCompiler

class ContentCompiler : System.Object

Provides methods for writing compiled binary format.

public ContentTypeWriter GetTypeWriter(System.Type type)

Retrieves the worker writer for the specified type.

Parameters:

• type (System.Type) – The type.

Returns:

The worker writer.

public void Compile(System.IO.Stream stream, System.Object content, TargetPlatform targetPlatform, GraphicsProfile targetProfile, bool compressContent, string rootDirectory, string referenceRelocationPath)

Write the content to a XNB file.

Parameters:

• stream (System.IO.Stream) – The stream to write the XNB file to.
• content (System.Object) – The content to write to the XNB file.
• targetPlatform (Microsoft.Xna.Framework.Content.Pipeline.TargetPlatform) – The platform the XNB is intended for.
• targetProfile (Microsoft.Xna.Framework.Graphics.GraphicsProfile) – The graphics profile of the target.
• compressContent (bool) – True if the content should be compressed.
• rootDirectory (string) – The root directory of the content.
• referenceRelocationPath (string) – The path of the XNB file, used to calculate relative paths for external references.

ContentIdentity

class ContentIdentity : System.Object

Provides properties describing the origin of the game asset, such as the original source file and creation tool. This information is used for error reporting, and by processors that need to determine from what directory the asset was originally loaded.

string FragmentIdentifier

Gets or sets the specific location of the content item within the larger source file.

string SourceFilename

Gets or sets the file name of the asset source.

string SourceTool

Gets or sets the creation tool of the asset.

ContentImporter<T>

class ContentImporter<T> : System.Object, IContentImporter

Implements a file format importer for use with game assets. Importers, either provided by the framework or written by a developer, must derive from ContentImporter, as well as being marked with a ContentImporterAttribute. An importer should produce results in the standard intermediate object model. If an asset has information not supported by the object model, the importer should output it as opaque data (key/value attributes attached to the relevant object). By following this procedure, a content pipeline can access specialized digital content creation (DCC) tool information, even when that information has not been fully standardized into the official object model. You can also design custom importers that accept and import types containing specific third-party extensions to the object model.

Type Parameters:  

• T –

public abstract Microsoft.Xna.Framework.Content.Pipeline.T Import(string filename, ContentImporterContext context)

Called by the framework when importing a game asset. This is the method called by XNA when an asset is to be imported into an object that can be recognized by the Content Pipeline.

Parameters:

• filename (string) – Name of a game asset file.
• context (Microsoft.Xna.Framework.Content.Pipeline.ContentImporterContext) – Contains information for importing a game asset, such as a logger interface.

Returns:

Resulting game asset.

ContentImporterAttribute

class ContentImporterAttribute : System.Attribute, System.Runtime.InteropServices._Attribute

Provides properties that identify and provide metadata about the importer, such as supported file extensions and caching information. Importers are required to initialize this attribute.

bool CacheImportedData

Gets and sets the caching of the content during importation.

string DefaultProcessor

Gets or sets the name of the default processor for content read by this importer.

string DisplayName

Gets or sets the string representing the importer in a user interface. This name is not used by the content pipeline and should not be passed to the BuildAssets task (a custom MSBuild task used by XNA Game Studio). It is used for display purposes only.

readonly System.Collections.Generic.IEnumerable<String> FileExtensions

Gets the supported file name extensions of the importer.

ContentImporterContext

class ContentImporterContext : System.Object

Provides properties that define logging behavior for the importer.

readonly string IntermediateDirectory

The absolute path to the root of the build intermediate (object) directory.

readonly ContentBuildLogger Logger

Gets the logger for an importer.

readonly string OutputDirectory

The absolute path to the root of the build output (binaries) directory.

public abstract void AddDependency(string filename)

Adds a dependency to the specified file. This causes a rebuild of the file, when modified, on subsequent incremental builds.

Parameters:

• filename (string) – Name of an asset file.

ContentItem

class ContentItem : System.Object

Provides properties that define various aspects of content stored using the intermediate file format of the XNA Framework.

ContentIdentity Identity

Gets or sets the identity of the content item.

string Name

Gets or sets the name of the content item.

readonly OpaqueDataDictionary OpaqueData

Gets the opaque data of the content item.

ContentProcessor<TInput, TOutput>

class ContentProcessor<TInput, TOutput> : System.Object, IContentProcessor

Provides a base class to use when developing custom processor components. All processors must derive from this class.

Type Parameters:  

• TInput –
• TOutput –

public abstract Microsoft.Xna.Framework.Content.Pipeline.TOutput Process(Microsoft.Xna.Framework.Content.Pipeline.TInput input, ContentProcessorContext context)

Parameters:

• input (Microsoft.Xna.Framework.Content.Pipeline.TInput) –
• context (Microsoft.Xna.Framework.Content.Pipeline.ContentProcessorContext) –

ContentProcessorAttribute

class ContentProcessorAttribute : System.Attribute, System.Runtime.InteropServices._Attribute

Gets any existing content processor components.

string DisplayName

Gets or sets the string representing the processor in a user interface. This name is not used by the content pipeline and should not be passed to the BuildAssets task (a custom MSBuild task used by XNA Game Studio). It is used for display purposes only.

ContentProcessorContext

class ContentProcessorContext : System.Object

Provides access to custom processor parameters, methods for converting member data, and triggering nested builds.

readonly string BuildConfiguration

Gets the name of the current content build configuration.

readonly string IntermediateDirectory

Gets the path of the directory that will contain any intermediate files generated by the content processor.

readonly ContentBuildLogger Logger

Gets the logger interface used for status messages or warnings.

readonly string OutputDirectory

Gets the output path of the content processor.

readonly string OutputFilename

Gets the output file name of the content processor.

readonly OpaqueDataDictionary Parameters

Gets the collection of parameters used by the content processor.

readonly TargetPlatform TargetPlatform

Gets the current content build target platform.

readonly GraphicsProfile TargetProfile

Gets the current content build target profile.

public abstract void AddDependency(string filename)

Adds a dependency to the specified file. This causes a rebuild of the file, when modified, on subsequent incremental builds.

Parameters:

• filename (string) – Name of an asset file.

public abstract void AddOutputFile(string filename)

Add a file name to the list of related output files maintained by the build item. This allows tracking build items that build multiple output files.

Parameters:

• filename (string) – The name of the file.

public Microsoft.Xna.Framework.Content.Pipeline.TOutput BuildAndLoadAsset<TInput, TOutput>(Microsoft.Xna.Framework.Content.Pipeline.ExternalReference<TInput> sourceAsset, string processorName)

Initiates a nested build of the specified asset and then loads the result into memory.

Type Parameters:  

• TInput – Type of the input.
• TOutput – Type of the converted output.

Parameters:

• sourceAsset (Microsoft.Xna.Framework.Content.Pipeline.ExternalReference<TInput>) – Reference to the source asset.
• processorName (string) – Optional processor for this content.

Returns:

Copy of the final converted content.

public abstract Microsoft.Xna.Framework.Content.Pipeline.TOutput BuildAndLoadAsset<TInput, TOutput>(Microsoft.Xna.Framework.Content.Pipeline.ExternalReference<TInput> sourceAsset, string processorName, OpaqueDataDictionary processorParameters, string importerName)

Initiates a nested build of the specified asset and then loads the result into memory.

Type Parameters:  

• TInput – Type of the input.
• TOutput – Type of the converted output.

Parameters:

• sourceAsset (Microsoft.Xna.Framework.Content.Pipeline.ExternalReference<TInput>) – Reference to the source asset.
• processorName (string) – Optional processor for this content.
• processorParameters (Microsoft.Xna.Framework.Content.Pipeline.OpaqueDataDictionary) – Optional collection of named values available as input to the content processor.
• importerName (string) – Optional importer for this content.

Returns:

Copy of the final converted content.

public Microsoft.Xna.Framework.Content.Pipeline.ExternalReference<TOutput> BuildAsset<TInput, TOutput>(Microsoft.Xna.Framework.Content.Pipeline.ExternalReference<TInput> sourceAsset, string processorName)

Initiates a nested build of an additional asset.

Type Parameters:  

• TInput – Type of the input.
• TOutput – Type of the output.

Parameters:

• sourceAsset (Microsoft.Xna.Framework.Content.Pipeline.ExternalReference<TInput>) – Reference to the source asset.
• processorName (string) – Optional processor for this content.

Returns:

Reference to the final compiled content. The build work is not required to complete before returning. Therefore, this file may not be up to date when BuildAsset returns but it will be available for loading by the game at runtime.

public abstract Microsoft.Xna.Framework.Content.Pipeline.ExternalReference<TOutput> BuildAsset<TInput, TOutput>(Microsoft.Xna.Framework.Content.Pipeline.ExternalReference<TInput> sourceAsset, string processorName, OpaqueDataDictionary processorParameters, string importerName, string assetName)

Initiates a nested build of an additional asset.

Type Parameters:  

• TInput – Type of the input.
• TOutput – Type of the output.

Parameters:

• sourceAsset (Microsoft.Xna.Framework.Content.Pipeline.ExternalReference<TInput>) – Reference to the source asset.
• processorName (string) – Optional processor for this content.
• processorParameters (Microsoft.Xna.Framework.Content.Pipeline.OpaqueDataDictionary) – Optional collection of named values available as input to the content processor.
• importerName (string) – Optional importer for this content.
• assetName (string) – Optional name of the final compiled content.

Returns:

Reference to the final compiled content. The build work is not required to complete before returning. Therefore, this file may not be up to date when BuildAsset returns but it will be available for loading by the game at runtime.

public Microsoft.Xna.Framework.Content.Pipeline.TOutput Convert<TInput, TOutput>(Microsoft.Xna.Framework.Content.Pipeline.TInput input, string processorName)

Type Parameters:  

• TInput –
• TOutput –

Parameters:

• input (Microsoft.Xna.Framework.Content.Pipeline.TInput) –
• processorName (string) –

public abstract Microsoft.Xna.Framework.Content.Pipeline.TOutput Convert<TInput, TOutput>(Microsoft.Xna.Framework.Content.Pipeline.TInput input, string processorName, OpaqueDataDictionary processorParameters)

Type Parameters:  

• TInput –
• TOutput –

Parameters:

• input (Microsoft.Xna.Framework.Content.Pipeline.TInput) –
• processorName (string) –
• processorParameters (Microsoft.Xna.Framework.Content.Pipeline.OpaqueDataDictionary) –

ContentTypeSerializer

class ContentTypeSerializer : System.Object

readonly bool CanDeserializeIntoExistingObject

readonly System.Type TargetType

readonly string XmlTypeName

abstract System.Object Deserialize(IntermediateReader input, ContentSerializerAttribute format, System.Object existingInstance)

Parameters:

• input (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.IntermediateReader) –
• format (Microsoft.Xna.Framework.Content.ContentSerializerAttribute) –
• existingInstance (System.Object) –

void Initialize(IntermediateSerializer serializer)

Parameters:

• serializer (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.IntermediateSerializer) –

public bool ObjectIsEmpty(System.Object value)

Parameters:

• value (System.Object) –

void ScanChildren(IntermediateSerializer serializer, Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.ChildCallback callback, System.Object value)

Parameters:

• serializer (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.IntermediateSerializer) –
• callback (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.ChildCallback) –
• value (System.Object) –

abstract void Serialize(IntermediateWriter output, System.Object value, ContentSerializerAttribute format)

Parameters:

• output (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.IntermediateWriter) –
• value (System.Object) –
• format (Microsoft.Xna.Framework.Content.ContentSerializerAttribute) –

ContentTypeSerializer<T>

class ContentTypeSerializer<T> : ContentTypeSerializer

Type Parameters:  

• T –

abstract Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T Deserialize(IntermediateReader input, ContentSerializerAttribute format, Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T existingInstance)

Parameters:

• input (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.IntermediateReader) –
• format (Microsoft.Xna.Framework.Content.ContentSerializerAttribute) –
• existingInstance (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T) –

System.Object Deserialize(IntermediateReader input, ContentSerializerAttribute format, System.Object existingInstance)

Parameters:

• input (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.IntermediateReader) –
• format (Microsoft.Xna.Framework.Content.ContentSerializerAttribute) –
• existingInstance (System.Object) –

public bool ObjectIsEmpty(Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T value)

Parameters:

• value (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T) –

public bool ObjectIsEmpty(System.Object value)

Parameters:

• value (System.Object) –

void ScanChildren(IntermediateSerializer serializer, Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.ChildCallback callback, Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T value)

Parameters:

• serializer (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.IntermediateSerializer) –
• callback (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.ChildCallback) –
• value (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T) –

void ScanChildren(IntermediateSerializer serializer, Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.ChildCallback callback, System.Object value)

Parameters:

• serializer (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.IntermediateSerializer) –
• callback (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.ChildCallback) –
• value (System.Object) –

abstract void Serialize(IntermediateWriter output, Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T value, ContentSerializerAttribute format)

Parameters:

• output (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.IntermediateWriter) –
• value (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T) –
• format (Microsoft.Xna.Framework.Content.ContentSerializerAttribute) –

void Serialize(IntermediateWriter output, System.Object value, ContentSerializerAttribute format)

Parameters:

• output (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.IntermediateWriter) –
• value (System.Object) –
• format (Microsoft.Xna.Framework.Content.ContentSerializerAttribute) –

ContentTypeSerializerAttribute

class ContentTypeSerializerAttribute : System.Attribute, System.Runtime.InteropServices._Attribute

Used to identify custom ContentTypeSerializer classes.

System.Collections.ObjectModel.ReadOnlyCollection<Type> GetTypes()

ContentTypeWriter

class ContentTypeWriter : System.Object

Provides methods and properties for compiling a specific managed type into a binary format.

readonly bool CanDeserializeIntoExistingObject

Determines if deserialization into an existing object is possible.

Value:true if the object can be deserialized into; false otherwise.

readonly System.Type TargetType

Gets the type handled by this compiler component.

Value:The type handled by this compiler component.

readonly int TypeVersion

Gets a format version number for this type.

Value:A format version number for this type.

public abstract string GetRuntimeReader(TargetPlatform targetPlatform)

Gets the assembly qualified name of the runtime loader for this type.

Parameters:

• targetPlatform (Microsoft.Xna.Framework.Content.Pipeline.TargetPlatform) – Name of the platform.

Returns:

Name of the runtime loader.

public string GetRuntimeType(TargetPlatform targetPlatform)

Gets the assembly qualified name of the runtime target type. The runtime target type often matches the design time type, but may differ.

Parameters:

• targetPlatform (Microsoft.Xna.Framework.Content.Pipeline.TargetPlatform) – The target platform.

Returns:

The qualified name.

void OnAddedToContentWriter(ContentWriter writer)

Allows type writers to add their element type writers to the content writer.

Parameters:

• writer (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Compiler.ContentWriter) – The content writer.

bool ShouldCompressContent(TargetPlatform targetPlatform, System.Object value)

Indicates whether a given type of content should be compressed.

Parameters:

• targetPlatform (Microsoft.Xna.Framework.Content.Pipeline.TargetPlatform) – The target platform of the content build.
• value (System.Object) – The object about to be serialized, or null if a collection of objects is to be serialized.

Returns:

true if the content of the requested type should be compressed; false otherwise.

abstract void Write(ContentWriter output, System.Object value)

Compiles an object into binary format.

Parameters:

• output (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Compiler.ContentWriter) – The content writer serializing the value.
• value (System.Object) – The resultant object.

ContentTypeWriter<T>

class ContentTypeWriter<T> : ContentTypeWriter

Provides a generic implementation of ContentTypeWriter methods and properties for compiling a specific managed type into a binary format.

Type Parameters:  

• T – The type to write

void Write(ContentWriter output, System.Object value)

Compiles a strongly typed object into binary format.

Parameters:

• output (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Compiler.ContentWriter) – The content writer serializing the value.
• value (System.Object) – The value to write.

abstract void Write(ContentWriter output, Microsoft.Xna.Framework.Content.Pipeline.Serialization.Compiler.T value)

Parameters:

• output (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Compiler.ContentWriter) –
• value (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Compiler.T) –

ContentTypeWriterAttribute

class ContentTypeWriterAttribute : System.Attribute, System.Runtime.InteropServices._Attribute

Identifies the components of a type writer. Custom content writers must apply this attribute to their class as well as extend the ContentTypeWriter class.

ContentWriter

class ContentWriter : System.IO.BinaryWriter, System.IDisposable

Provides an implementation for many of the ContentCompiler methods including compilation, state tracking for shared resources and creation of the header type manifest.

readonly TargetPlatform TargetPlatform

Gets the content build target platform.

readonly GraphicsProfile TargetProfile

Gets or sets the target graphics profile.

public void Flush()

All content has been written, so now finalize the header, footer and anything else that needs finalizing.

ContentTypeWriter GetTypeWriter(System.Type type)

Gets a ContentTypeWriter for the given type.

Parameters:

• type (System.Type) – The type of the object to write.

Returns:

The ContentTypeWriter for the type.

public void WriteExternalReference<T>(ExternalReference<T> reference)

Writes the name of an external file to the output binary.

Type Parameters:  

• T – The type of reference.

Parameters:

• reference (Microsoft.Xna.Framework.Content.Pipeline.ExternalReference<T>) – External reference to a data file for the content item.

public void WriteObject<T>(Microsoft.Xna.Framework.Content.Pipeline.Serialization.Compiler.T value)

Type Parameters:  

• T –

Parameters:

• value (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Compiler.T) –

public void WriteObject<T>(Microsoft.Xna.Framework.Content.Pipeline.Serialization.Compiler.T value, ContentTypeWriter typeWriter)

Type Parameters:  

• T –

Parameters:

• value (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Compiler.T) –
• typeWriter (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Compiler.ContentTypeWriter) –

public void WriteRawObject<T>(Microsoft.Xna.Framework.Content.Pipeline.Serialization.Compiler.T value)

Type Parameters:  

• T –

Parameters:

• value (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Compiler.T) –

public void WriteRawObject<T>(Microsoft.Xna.Framework.Content.Pipeline.Serialization.Compiler.T value, ContentTypeWriter typeWriter)

Type Parameters:  

• T –

Parameters:

• value (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Compiler.T) –
• typeWriter (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Compiler.ContentTypeWriter) –

public void WriteSharedResource<T>(Microsoft.Xna.Framework.Content.Pipeline.Serialization.Compiler.T value)

Type Parameters:  

• T –

Parameters:

• value (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Compiler.T) –

public void Write(Color value)

Writes a Color value.

Parameters:

• value (Microsoft.Xna.Framework.Color) – Value of a color using Red, Green, Blue, and Alpha values to write.

public void Write(Matrix value)

Writes a Matrix value.

Parameters:

• value (Microsoft.Xna.Framework.Matrix) – Value to write.

public void Write(Quaternion value)

Writes a Matrix value.

Parameters:

• value (Microsoft.Xna.Framework.Quaternion) – Value to write.

public void Write(Vector2 value)

Writes a Vector2 value.

Parameters:

• value (Microsoft.Xna.Framework.Vector2) – Value to write.

public void Write(Vector3 value)

Writes a Vector3 value.

Parameters:

• value (Microsoft.Xna.Framework.Vector3) – Value to write.

public void Write(Vector4 value)

Writes a Vector4 value.

Parameters:

• value (Microsoft.Xna.Framework.Vector4) – Value to write.

void Write(BoundingSphere value)

Writes a BoundingSphere value.

Parameters:

• value (Microsoft.Xna.Framework.BoundingSphere) – Value to write.

void Write(Rectangle value)

Writes a Rectangle value.

Parameters:

• value (Microsoft.Xna.Framework.Rectangle) – Value to write.

bool CanDeserializeIntoExistingObject(System.Type type)

Helper for checking if a type can be deserialized into an existing object.

Parameters:

• type (System.Type) – The type to check.

Returns:

True if the type can be deserialized into an existing object.

ConversionFormat

enum ConversionFormat : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Target formats supported for audio source conversions.

ConversionFormat Adpcm

Microsoft ADPCM encoding technique using 4 bits

ConversionFormat Pcm

8/16-bit mono/stereo PCM audio 8KHz-48KHz

ConversionFormat WindowsMedia

Windows Media CBR formats (64 kbps, 128 kbps, 192 kbps)

ConversionFormat Xma

The Xbox compression format

ConversionFormat ImaAdpcm

QuickTime ADPCM format

ConversionFormat Aac

Advanced Audio Coding

ConversionFormat Vorbis

Vorbis open, patent-free audio encoding

ConversionQuality

enum ConversionQuality : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Compression quality of the audio content.

ConversionQuality Low

High compression yielding lower file size, but could compromise audio quality

ConversionQuality Medium

Moderate compression resulting in a compromise between audio quality and file size

ConversionQuality Best

Lowest compression, but the best audio quality

DualTextureMaterialContent

class DualTextureMaterialContent : MaterialContent

string AlphaKey

string DiffuseColorKey

string TextureKey

string Texture2Key

string VertexColorEnabledKey

System.Nullable<Single> Alpha

System.Nullable<Vector3> DiffuseColor

Microsoft.Xna.Framework.Content.Pipeline.ExternalReference<TextureContent> Texture

Microsoft.Xna.Framework.Content.Pipeline.ExternalReference<TextureContent> Texture2

System.Nullable<Boolean> VertexColorEnabled

Dxt1BitmapContent

class Dxt1BitmapContent : DxtBitmapContent

public bool TryGetFormat(ref SurfaceFormat format)

Parameters:

• (ref) format (Microsoft.Xna.Framework.Graphics.SurfaceFormat) –

public string ToString()

Returns a string description of the bitmap.

Returns:Description of the bitmap.

Dxt3BitmapContent

class Dxt3BitmapContent : DxtBitmapContent

public bool TryGetFormat(ref SurfaceFormat format)

Parameters:

• (ref) format (Microsoft.Xna.Framework.Graphics.SurfaceFormat) –

public string ToString()

Returns a string description of the bitmap.

Returns:Description of the bitmap.

Dxt5BitmapContent

class Dxt5BitmapContent : DxtBitmapContent

public bool TryGetFormat(ref SurfaceFormat format)

Parameters:

• (ref) format (Microsoft.Xna.Framework.Graphics.SurfaceFormat) –

public string ToString()

Returns a string description of the bitmap.

Returns:Description of the bitmap.

DxtBitmapContent

class DxtBitmapContent : BitmapContent

public System.Byte[] GetPixelData()

public void SetPixelData(System.Byte[] sourceData)

Parameters:

• sourceData (System.Byte[]) –

EffectContent

class EffectContent : ContentItem

Contains the source code for a DirectX Effect, loaded from a .fx file.

string EffectCode

Gets or sets the effect program source code.

EffectImporter

class EffectImporter : Microsoft.Xna.Framework.Content.Pipeline.ContentImporter<EffectContent>, IContentImporter

Provides methods for reading effect (.fx) files for use in the Content Pipeline.

public EffectContent Import(string filename, ContentImporterContext context)

Called by the XNA Framework when importing an .fx file to be used as a game asset. This is the method called by the XNA Framework when an asset is to be imported into an object that can be recognized by the Content Pipeline.

Parameters:

• filename (string) – Name of a game asset file.
• context (Microsoft.Xna.Framework.Content.Pipeline.ContentImporterContext) – Contains information for importing a game asset, such as a logger interface.

Returns:

Resulting game asset.

EffectMaterialContent

class EffectMaterialContent : MaterialContent

string EffectKey

string CompiledEffectKey

Microsoft.Xna.Framework.Content.Pipeline.ExternalReference<EffectContent> Effect

Microsoft.Xna.Framework.Content.Pipeline.ExternalReference<CompiledEffectContent> CompiledEffect

EffectProcessor

class EffectProcessor : Microsoft.Xna.Framework.Content.Pipeline.ContentProcessor<EffectContent, CompiledEffectContent>, IContentProcessor

Processes a string representation to a platform-specific compiled effect.

EffectProcessorDebugMode DebugMode

The debug mode for compiling effects.

Value:The debug mode to use when compiling effects.

string Defines

Define assignments for the effect.

Value:A list of define assignments delimited by semicolons.

public CompiledEffectContent Process(EffectContent input, ContentProcessorContext context)

Processes the string representation of the specified effect into a platform-specific binary format using the specified context.

Parameters:

• input (Microsoft.Xna.Framework.Content.Pipeline.Graphics.EffectContent) – The effect string to be processed.
• context (Microsoft.Xna.Framework.Content.Pipeline.ContentProcessorContext) – Context for the specified processor.

Returns:

A platform-specific compiled binary effect.

EffectProcessorDebugMode

enum EffectProcessorDebugMode : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Specifies how debugging of effects is to be supported in PIX.

EffectProcessorDebugMode Auto

Enables effect debugging when built with Debug profile.

EffectProcessorDebugMode Debug

Enables effect debugging for all profiles. Will produce unoptimized shaders.

EffectProcessorDebugMode Optimize

Disables debugging for all profiles, produce optimized shaders.

EnvironmentMapMaterialContent

class EnvironmentMapMaterialContent : MaterialContent

string AlphaKey

string DiffuseColorKey

string EmissiveColorKey

string EnvironmentMapKey

string EnvironmentMapAmountKey

string EnvironmentMapSpecularKey

string FresnelFactorKey

string TextureKey

System.Nullable<Single> Alpha

System.Nullable<Vector3> DiffuseColor

System.Nullable<Vector3> EmissiveColor

Microsoft.Xna.Framework.Content.Pipeline.ExternalReference<TextureContent> EnvironmentMap

System.Nullable<Single> EnvironmentMapAmount

System.Nullable<Vector3> EnvironmentMapSpecular

System.Nullable<Single> FresnelFactor

Microsoft.Xna.Framework.Content.Pipeline.ExternalReference<TextureContent> Texture

Etc1BitmapContent

class Etc1BitmapContent : BitmapContent

Supports the processing of a texture compressed using ETC1.

public System.Byte[] GetPixelData()

public void SetPixelData(System.Byte[] sourceData)

Parameters:

• sourceData (System.Byte[]) –

public bool TryGetFormat(ref SurfaceFormat format)

Parameters:

• (ref) format (Microsoft.Xna.Framework.Graphics.SurfaceFormat) –

public string ToString()

Returns a string description of the bitmap.

Returns:Description of the bitmap.

ExternalReference<T>

class ExternalReference<T> : ContentItem

Specifies external references to a data file for the content item.

While the object model is instantiated, reference file names are absolute. When the file containing the external reference is serialized to disk, file names are relative to the file. This allows movement of the content tree to a different location without breaking internal links.

Type Parameters:  

• T –

string Filename

Gets and sets the file name of an ExternalReference.

FbxImporter

class FbxImporter : Microsoft.Xna.Framework.Content.Pipeline.ContentImporter<NodeContent>, IContentImporter

Provides methods for reading AutoDesk (.fbx) files for use in the Content Pipeline.

public NodeContent Import(string filename, ContentImporterContext context)

Parameters:

• filename (string) –
• context (Microsoft.Xna.Framework.Content.Pipeline.ContentImporterContext) –

FileHelper

class FileHelper : System.Object

public void DeleteIfExists(string path)

Checks deletes a file from disk without throwing exceptions.

Parameters:

• path (string) –

FontDescription

class FontDescription : ContentItem

Provides information to the FontDescriptionProcessor describing which font to rasterize, which font size to utilize, and which Unicode characters to include in the processor output.

string FontName

Gets or sets the name of the font, such as “Times New Roman” or “Arial”. This value cannot be null or empty.

float Size

Gets or sets the size, in points, of the font.

float Spacing

Gets or sets the amount of space, in pixels, to insert between letters in a string.

bool UseKerning

Indicates if kerning information is used when drawing characters.

FontDescriptionStyle Style

Gets or sets the style of the font, expressed as a combination of one or more FontDescriptionStyle flags.

System.Nullable<Char> DefaultCharacter

Gets or sets the default character for the font.

readonly System.Collections.Generic.ICollection<Char> Characters

Microsoft.Xna.Framework.Content.Pipeline.Graphics.CharacterRegion[] get_CharacterRegions()

void set_CharacterRegions(Microsoft.Xna.Framework.Content.Pipeline.Graphics.CharacterRegion[] value)

Parameters:

• value (Microsoft.Xna.Framework.Content.Pipeline.Graphics.CharacterRegion[]) –

void set_Characters(System.Collections.Generic.ICollection<Char> value)

Parameters:

• value (System.Collections.Generic.ICollection<Char>) –

FontDescriptionImporter

class FontDescriptionImporter : Microsoft.Xna.Framework.Content.Pipeline.ContentImporter<FontDescription>, IContentImporter

Provides methods for reading .spritefont files for use in the Content Pipeline.

public FontDescription Import(string filename, ContentImporterContext context)

Called by the XNA Framework when importing a .spritefont file to be used as a game asset. This is the method called by the XNA Framework when an asset is to be imported into an object that can be recognized by the Content Pipeline.

Parameters:

• filename (string) – Name of a game asset file.
• context (Microsoft.Xna.Framework.Content.Pipeline.ContentImporterContext) – Contains information for importing a game asset, such as a logger interface.

Returns:

Resulting game asset.

FontDescriptionProcessor

class FontDescriptionProcessor : Microsoft.Xna.Framework.Content.Pipeline.ContentProcessor<FontDescription, SpriteFontContent>, IContentProcessor

bool PremultiplyAlpha

TextureProcessorOutputFormat TextureFormat

public SpriteFontContent Process(FontDescription input, ContentProcessorContext context)

Parameters:

• input (Microsoft.Xna.Framework.Content.Pipeline.Graphics.FontDescription) –
• context (Microsoft.Xna.Framework.Content.Pipeline.ContentProcessorContext) –

FontDescriptionStyle

enum FontDescriptionStyle : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Flags that describe style information to be applied to text. You can combine these flags by using a bitwise OR operator (|).

FontDescriptionStyle Bold

Bold text.

FontDescriptionStyle Italic

Italic text.

FontDescriptionStyle Regular

Normal text.

FontTextureProcessor

class FontTextureProcessor : Microsoft.Xna.Framework.Content.Pipeline.ContentProcessor<Texture2DContent, SpriteFontContent>, IContentProcessor

char FirstCharacter

bool PremultiplyAlpha

TextureProcessorOutputFormat TextureFormat

public SpriteFontContent Process(Texture2DContent input, ContentProcessorContext context)

Parameters:

• input (Microsoft.Xna.Framework.Content.Pipeline.Graphics.Texture2DContent) –
• context (Microsoft.Xna.Framework.Content.Pipeline.ContentProcessorContext) –

GeometryContent

class GeometryContent : ContentItem

Provides properties that define various aspects of a geometry batch.

readonly IndexCollection Indices

Gets the list of triangle indices for this geometry batch. Geometry is stored as an indexed triangle list, where each group of three indices defines a single triangle.

MaterialContent Material

Gets or sets the material of the parent mesh.

MeshContent Parent

Gets or sets the parent MeshContent for this object.

readonly VertexContent Vertices

Gets the set of vertex batches for the geometry batch.

GeometryContentCollection

class GeometryContentCollection : Microsoft.Xna.Framework.Content.Pipeline.ChildCollection<MeshContent, GeometryContent>, System.Collections.Generic.IList<GeometryContent>, System.Collections.Generic.ICollection<GeometryContent>, System.Collections.Generic.IEnumerable<GeometryContent>, System.Collections.IEnumerable, System.Collections.IList, System.Collections.ICollection, System.Collections.Generic.IReadOnlyList<GeometryContent>, System.Collections.Generic.IReadOnlyCollection<GeometryContent>

Provides methods for maintaining a collection of geometry batches that make up a mesh.

GraphicsUtil

class GraphicsUtil : System.Object

BitmapContent Resize(BitmapContent bitmap, int newWidth, int newHeight)

Parameters:

• bitmap (Microsoft.Xna.Framework.Content.Pipeline.Graphics.BitmapContent) –
• newWidth (int) –
• newHeight (int) –

public void BGRAtoRGBA(System.Byte[] data)

Parameters:

• data (System.Byte[]) –

public bool IsPowerOfTwo(int x)

Parameters:

• x (int) –

public int GetNextPowerOfTwo(int value)

Returns the next power of two. Returns same value if already is PoT.

Parameters:

• value (int) –

public void CompressPvrtc(TextureContent content, bool generateMipMaps, bool isSpriteFont)

Parameters:

• content (Microsoft.Xna.Framework.Content.Pipeline.Graphics.TextureContent) –
• generateMipMaps (bool) –
• isSpriteFont (bool) –

public void CompressDxt(GraphicsProfile profile, TextureContent content, bool generateMipMaps, bool isSpriteFont)

Parameters:

• profile (Microsoft.Xna.Framework.Graphics.GraphicsProfile) –
• content (Microsoft.Xna.Framework.Content.Pipeline.Graphics.TextureContent) –
• generateMipMaps (bool) –
• isSpriteFont (bool) –

public void CompressAti(TextureContent content, bool generateMipMaps)

Parameters:

• content (Microsoft.Xna.Framework.Content.Pipeline.Graphics.TextureContent) –
• generateMipMaps (bool) –

public void CompressEtc1(TextureContent content, bool generateMipMaps)

Parameters:

• content (Microsoft.Xna.Framework.Content.Pipeline.Graphics.TextureContent) –
• generateMipMaps (bool) –

public void CompressColor16Bit(TextureContent content, bool generateMipMaps)

Parameters:

• content (Microsoft.Xna.Framework.Content.Pipeline.Graphics.TextureContent) –
• generateMipMaps (bool) –

public void CompressFontDXT3(TextureContent content, bool generateMipmaps)

Parameters:

• content (Microsoft.Xna.Framework.Content.Pipeline.Graphics.TextureContent) –
• generateMipmaps (bool) –

H264Importer

class H264Importer : Microsoft.Xna.Framework.Content.Pipeline.ContentImporter<VideoContent>, IContentImporter

public VideoContent Import(string filename, ContentImporterContext context)

Parameters:

• filename (string) –
• context (Microsoft.Xna.Framework.Content.Pipeline.ContentImporterContext) –

IContentImporter

interface IContentImporter

Accesses a statically typed ContentImporter instance from generic code using dynamic typing.

System.Object Import(string filename, ContentImporterContext context)

Imports an asset from the specified file.

Parameters:

• filename (string) – Name of the game asset file.
• context (Microsoft.Xna.Framework.Content.Pipeline.ContentImporterContext) – A ContentImporterContext class containing information for importing a game asset, such as a logger interface.

Returns:

Resulting game asset.

IContentProcessor

interface IContentProcessor

Provides methods and properties for accessing a statically typed ContentProcessor subclass, using dynamically typed object data.

readonly System.Type InputType

Gets the expected object type of the input parameter to IContentProcessor.Process.

readonly System.Type OutputType

Gets the object type returned by IContentProcessor.Process.

System.Object Process(System.Object input, ContentProcessorContext context)

Processes the specified input data and returns the result.

Parameters:

• input (System.Object) – Existing content object being processed.
• context (Microsoft.Xna.Framework.Content.Pipeline.ContentProcessorContext) – Contains any required custom process parameters.

Returns:

An object representing the processed input.

IEffectCompilerOutput

interface IEffectCompilerOutput

void WriteWarning(string file, int line, int column, string message)

Parameters:

• file (string) –
• line (int) –
• column (int) –
• message (string) –

void WriteError(string file, int line, int column, string message)

Parameters:

• file (string) –
• line (int) –
• column (int) –
• message (string) –

IndexCollection

class IndexCollection : System.Collections.ObjectModel.Collection<Int32>, System.Collections.Generic.IList<Int32>, System.Collections.Generic.ICollection<Int32>, System.Collections.Generic.IEnumerable<Int32>, System.Collections.IEnumerable, System.Collections.IList, System.Collections.ICollection, System.Collections.Generic.IReadOnlyList<Int32>, System.Collections.Generic.IReadOnlyCollection<Int32>

Provides methods for maintaining a list of index values.

public void AddRange(System.Collections.Generic.IEnumerable<Int32> indices)

Add a range of indices to the collection.

Parameters:

• indices (System.Collections.Generic.IEnumerable<Int32>) – A collection of indices to add.

IndirectPositionCollection

class IndirectPositionCollection : System.Object, System.Collections.Generic.IList<Vector3>, System.Collections.Generic.ICollection<Vector3>, System.Collections.Generic.IEnumerable<Vector3>, System.Collections.IEnumerable

Provides methods for maintaining a list of vertex positions.

readonly int Count

Number of positions in the collection.

Value:Number of positions.

Vector3 Item

public bool Contains(Vector3 item)

Determines whether the specified position is in the collection.

Parameters:

• item (Microsoft.Xna.Framework.Vector3) – Position being searched for in the collection.

Returns:

true if the position was found; false otherwise.

public void CopyTo(Microsoft.Xna.Framework.Vector3[] array, int arrayIndex)

Copies the specified positions to an array, starting at the specified index.

Parameters:

• array (Microsoft.Xna.Framework.Vector3[]) – Array of positions to be copied.
• arrayIndex (int) – Index of the first copied position.

public System.Collections.Generic.IEnumerator<Vector3> GetEnumerator()

Gets an enumerator interface for reading the position values.

Returns:Interface for enumerating the collection of position values.

public int IndexOf(Vector3 item)

Gets the index of the specified position in a collection.

Parameters:

• item (Microsoft.Xna.Framework.Vector3) – Position being searched for.

Returns:

Index of the specified position or -1 if not found.

System.Exception Readonly()

IntermediateReader

class IntermediateReader : System.Object

readonly System.Xml.XmlReader Xml

readonly IntermediateSerializer Serializer

public bool MoveToElement(string elementName)

Parameters:

• elementName (string) –

public Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T ReadObject<T>(ContentSerializerAttribute format)

Type Parameters:  

• T –

Parameters:

• format (Microsoft.Xna.Framework.Content.ContentSerializerAttribute) –

public Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T ReadObject<T>(ContentSerializerAttribute format, ContentTypeSerializer typeSerializer)

Type Parameters:  

• T –

Parameters:

• format (Microsoft.Xna.Framework.Content.ContentSerializerAttribute) –
• typeSerializer (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.ContentTypeSerializer) –

public Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T ReadObject<T>(ContentSerializerAttribute format, ContentTypeSerializer typeSerializer, Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T existingInstance)

Type Parameters:  

• T –

Parameters:

• format (Microsoft.Xna.Framework.Content.ContentSerializerAttribute) –
• typeSerializer (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.ContentTypeSerializer) –
• existingInstance (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T) –

public Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T ReadObject<T>(ContentSerializerAttribute format, Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T existingInstance)

Type Parameters:  

• T –

Parameters:

• format (Microsoft.Xna.Framework.Content.ContentSerializerAttribute) –
• existingInstance (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T) –

public Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T ReadRawObject<T>(ContentSerializerAttribute format)

Type Parameters:  

• T –

Parameters:

• format (Microsoft.Xna.Framework.Content.ContentSerializerAttribute) –

public Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T ReadRawObject<T>(ContentSerializerAttribute format, ContentTypeSerializer typeSerializer)

Type Parameters:  

• T –

Parameters:

• format (Microsoft.Xna.Framework.Content.ContentSerializerAttribute) –
• typeSerializer (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.ContentTypeSerializer) –

public Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T ReadRawObject<T>(ContentSerializerAttribute format, ContentTypeSerializer typeSerializer, Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T existingInstance)

Type Parameters:  

• T –

Parameters:

• format (Microsoft.Xna.Framework.Content.ContentSerializerAttribute) –
• typeSerializer (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.ContentTypeSerializer) –
• existingInstance (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T) –

public Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T ReadRawObject<T>(ContentSerializerAttribute format, Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T existingInstance)

Type Parameters:  

• T –

Parameters:

• format (Microsoft.Xna.Framework.Content.ContentSerializerAttribute) –
• existingInstance (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T) –

public void ReadSharedResource<T>(ContentSerializerAttribute format, System.Action<T> fixup)

Type Parameters:  

• T –

Parameters:

• format (Microsoft.Xna.Framework.Content.ContentSerializerAttribute) –
• fixup (System.Action<T>) –

void ReadSharedResources()

public void ReadExternalReference<T>(ExternalReference<T> existingInstance)

Type Parameters:  

• T –

Parameters:

• existingInstance (Microsoft.Xna.Framework.Content.Pipeline.ExternalReference<T>) –

void ReadExternalReferences()

InvalidContentException NewInvalidContentException(System.Exception innerException, string message, System.Object[] args)

Parameters:

• innerException (System.Exception) –
• message (string) –
• args (System.Object[]) –

public System.Type ReadTypeName()

Reads the next type in the

Returns:

IntermediateSerializer

class IntermediateSerializer : System.Object

public Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T Deserialize<T>(System.Xml.XmlReader input, string referenceRelocationPath)

Type Parameters:  

• T –

Parameters:

• input (System.Xml.XmlReader) –
• referenceRelocationPath (string) –

public ContentTypeSerializer GetTypeSerializer(System.Type type)

Parameters:

• type (System.Type) –

Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.GenericCollectionHelper GetCollectionHelper(System.Type type)

Parameters:

• type (System.Type) –

public void Serialize<T>(System.Xml.XmlWriter output, Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T value, string referenceRelocationPath)

Type Parameters:  

• T –

Parameters:

• output (System.Xml.XmlWriter) –
• value (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T) –
• referenceRelocationPath (string) –

System.Type FindType(string typeName)

Finds the type in any assembly loaded into the AppDomain.

Parameters:

• typeName (string) –

string GetFullTypeName(System.Type type)

Gets the (potentially) aliased name for any type.

Parameters:

• type (System.Type) –

string GetTypeName(System.Type type)

Returns the name of the type, without the namespace. For generic types, we add the type parameters in square brackets. i.e. List<int> becomes List[int]

Parameters:

• type (System.Type) –

bool AlreadyScanned(System.Object value)

Parameters:

• value (System.Object) –

bool HasTypeAlias(System.Type type)

Parameters:

• type (System.Type) –

IntermediateWriter

class IntermediateWriter : System.Object

readonly System.Xml.XmlWriter Xml

readonly IntermediateSerializer Serializer

public void WriteExternalReference<T>(ExternalReference<T> value)

Type Parameters:  

• T –

Parameters:

• value (Microsoft.Xna.Framework.Content.Pipeline.ExternalReference<T>) –

public void WriteObject<T>(Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T value, ContentSerializerAttribute format)

Type Parameters:  

• T –

Parameters:

• value (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T) –
• format (Microsoft.Xna.Framework.Content.ContentSerializerAttribute) –

public void WriteObject<T>(Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T value, ContentSerializerAttribute format, ContentTypeSerializer typeSerializer)

Type Parameters:  

• T –

Parameters:

• value (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T) –
• format (Microsoft.Xna.Framework.Content.ContentSerializerAttribute) –
• typeSerializer (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.ContentTypeSerializer) –

void WriteObjectInternal(System.Object value, ContentSerializerAttribute format, ContentTypeSerializer typeSerializer, System.Type declaredType)

Parameters:

• value (System.Object) –
• format (Microsoft.Xna.Framework.Content.ContentSerializerAttribute) –
• typeSerializer (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.ContentTypeSerializer) –
• declaredType (System.Type) –

public void WriteRawObject<T>(Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T value, ContentSerializerAttribute format)

Type Parameters:  

• T –

Parameters:

• value (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T) –
• format (Microsoft.Xna.Framework.Content.ContentSerializerAttribute) –

public void WriteRawObject<T>(Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T value, ContentSerializerAttribute format, ContentTypeSerializer typeSerializer)

Type Parameters:  

• T –

Parameters:

• value (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T) –
• format (Microsoft.Xna.Framework.Content.ContentSerializerAttribute) –
• typeSerializer (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.ContentTypeSerializer) –

public void WriteSharedResource<T>(Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T value, ContentSerializerAttribute format)

Type Parameters:  

• T –

Parameters:

• value (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate.T) –
• format (Microsoft.Xna.Framework.Content.ContentSerializerAttribute) –

void WriteSharedResources()

void WriteExternalReferences()

public void WriteTypeName(System.Type type)

Parameters:

• type (System.Type) –

InvalidContentException

class InvalidContentException : System.Exception, System.Runtime.Serialization.ISerializable, System.Runtime.InteropServices._Exception

Thrown when errors are encountered in content during processing.

ContentIdentity ContentIdentity

Gets or sets the identity of the content item that caused the exception.

public void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context)

When overridden in a derived class, returns information about the exception. In addition to the base behavior, this method provides serialization functionality.

Parameters:

• info (System.Runtime.Serialization.SerializationInfo) – Information necessary for serialization and deserialization of the content item.
• context (System.Runtime.Serialization.StreamingContext) – Information necessary for the source and destination of a given serialized stream. Also provides an additional caller-defined context.

LoadedTypeCollection<T>

class LoadedTypeCollection<T> : System.Object, System.Collections.Generic.IEnumerable<T>, System.Collections.IEnumerable

A helper for collecting instances of a particular type by scanning the types in loaded assemblies.

Type Parameters:  

• T –

public System.Collections.Generic.IEnumerator<T> GetEnumerator()

MaterialContent

class MaterialContent : ContentItem

Provides methods and properties for maintaining a collection of named texture references.

readonly TextureReferenceDictionary Textures

Gets the texture collection of the material.

Value:Collection of textures used by the material.

public MaterialContent Clone()

Helper method to make a copy of a material.

Returns:A clone of the material.

MaterialProcessor

class MaterialProcessor : Microsoft.Xna.Framework.Content.Pipeline.ContentProcessor<MaterialContent, MaterialContent>, IContentProcessor

Provides methods and properties for maintaining a collection of named texture references.

Color ColorKeyColor

Gets or sets the color value to replace with transparent black.

Value:Color value of the material to replace with transparent black.

bool ColorKeyEnabled

Specifies whether color keying of a texture is enabled.

Value:true if color keying is enabled; false otherwise.

MaterialProcessorDefaultEffect DefaultEffect

The default effect type for this instance of MaterialProcessor.

Value:The default effect type.

bool GenerateMipmaps

Specifies if a full chain of mipmaps are generated from the source material. Existing mipmaps of the material are not replaced.

Value:true if mipmap generation is enabled; false otherwise.

bool PremultiplyTextureAlpha

Specifies whether alpha premultiply of textures is enabled.

Value:true if alpha premultiply is enabled; false otherwise.

bool ResizeTexturesToPowerOfTwo

Specifies whether resizing of a material is enabled. Typically used to maximize compatability with a graphics card because many graphics cards do not support a material size that is not a power of two. If ResizeTexturesToPowerOfTwo is enabled, the material is resized to the next largest power of two.

Value:true if resizing is enabled; false otherwise.

TextureProcessorOutputFormat TextureFormat

Specifies the texture format of output materials. Materials can either be left unchanged from the source asset, converted to a corresponding Color, or compressed using the appropriate DxtCompressed format.

Value:The texture format of the output.

public MaterialContent Process(MaterialContent input, ContentProcessorContext context)

Builds the texture and effect content for the material.

Parameters:

• input (Microsoft.Xna.Framework.Content.Pipeline.Graphics.MaterialContent) – The material content to build.
• context (Microsoft.Xna.Framework.Content.Pipeline.ContentProcessorContext) – Context for the specified processor.

Returns:

The built material.

public MaterialContent CreateDefaultMaterial(MaterialProcessorDefaultEffect effect)

Helper method which returns the material for a default effect.

Parameters:

• effect (Microsoft.Xna.Framework.Content.Pipeline.Processors.MaterialProcessorDefaultEffect) –

Returns:

A material.

public MaterialProcessorDefaultEffect GetDefaultEffect(MaterialContent content)

Helper method which returns the default effect for a material.

Parameters:

• content (Microsoft.Xna.Framework.Content.Pipeline.Graphics.MaterialContent) –

Returns:

The default effect.

MaterialProcessorDefaultEffect

enum MaterialProcessorDefaultEffect : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Specifies the default effect type.

MaterialProcessorDefaultEffect BasicEffect

A BasicEffect Class effect.

MaterialProcessorDefaultEffect SkinnedEffect

A SkinnedEffect Class effect.

MaterialProcessorDefaultEffect EnvironmentMapEffect

An EnvironmentMapEffect Class effect.

MaterialProcessorDefaultEffect DualTextureEffect

A DualTextureEffect Class effect.

MaterialProcessorDefaultEffect AlphaTestEffect

An AlphaTestEffect Class effect.

MeshBuilder

class MeshBuilder : System.Object

bool MergeDuplicatePositions

Gets or sets the current value for position merging of the mesh.

float MergePositionTolerance

Gets or sets the tolerance for P:Microsoft.Xna.Framework.Content.Pipeline.Graphics.MeshBuilder.MergeDuplicatePositions.

string Name

Gets or sets the name of the current T:Microsoft.Xna.Framework.Content.Pipeline.Graphics.MeshContent object being processed.

bool SwapWindingOrder

Reverses the triangle winding order of the specified mesh.

public void AddTriangleVertex(int indexIntoVertexCollection)

Adds a vertex into the index collection.

Parameters:

• indexIntoVertexCollection (int) –

  Index of the inserted vertex, in the collection.

  This corresponds to the value returned by M:Microsoft.Xna.Framework.Content.Pipeline.Graphics.MeshBuilder.CreatePosition(System.Single,System.Single,System.Single).

public int CreateVertexChannel<T>(string usage)

Type Parameters:  

• T –

Parameters:

• usage (string) –

public int CreatePosition(float x, float y, float z)

Inserts the specified vertex position into the vertex channel.

Parameters:

• x (float) – Value of the x component of the vector.
• y (float) – Value of the y component of the vector.
• z (float) – Value of the z component of the vector.

Returns:

Index of the inserted vertex.

public int CreatePosition(Vector3 pos)

Inserts the specified vertex position into the vertex channel at the specified index.

Parameters:

• pos (Microsoft.Xna.Framework.Vector3) – Value of the vertex being inserted.

Returns:

Index of the vertex being inserted.

public MeshContent FinishMesh()

Ends the creation of a mesh.

Returns:Resultant mesh.

public void SetMaterial(MaterialContent material)

Sets the material for the next triangles.

Parameters:

• material (Microsoft.Xna.Framework.Content.Pipeline.Graphics.MaterialContent) – Material for the next triangles.

public void SetOpaqueData(OpaqueDataDictionary opaqueData)

Sets the opaque data for the next triangles.

Parameters:

• opaqueData (Microsoft.Xna.Framework.Content.Pipeline.OpaqueDataDictionary) – Opaque data dictionary for the next triangles.

public void SetVertexChannelData(int vertexDataIndex, System.Object channelData)

Sets the specified vertex data with new data.

Parameters:

• vertexDataIndex (int) – Index of the vertex data channel being set. This should match the index returned by CreateVertexChannel.
• channelData (System.Object) – New data values for the vertex data. The data type being set must match the data type for the vertex channel specified by vertexDataIndex.

public MeshBuilder StartMesh(string name)

Initializes the creation of a mesh.

Parameters:

• name (string) – Name of the mesh.

Returns:

Object used when building the mesh.

MeshContent

class MeshContent : NodeContent

Provides properties and methods that define various aspects of a mesh.

readonly GeometryContentCollection Geometry

Gets the list of geometry batches for the mesh.

readonly PositionCollection Positions

Gets the list of vertex position values.

void TransformContents(ref Matrix xform)

Parameters:

• (ref) xform (Microsoft.Xna.Framework.Matrix) –

MeshHelper

class MeshHelper : System.Object

public void CalculateNormals(MeshContent mesh, bool overwriteExistingNormals)

Generates vertex normals by accumulation of triangle face normals.

Parameters:

• mesh (Microsoft.Xna.Framework.Content.Pipeline.Graphics.MeshContent) – The mesh which will recieve the normals.
• overwriteExistingNormals (bool) – Overwrite or skip over geometry with existing normals.

public void CalculateNormals(GeometryContent geom, bool overwriteExistingNormals)

Generates vertex normals by accumulation of triangle face normals.

Parameters:

• geom (Microsoft.Xna.Framework.Content.Pipeline.Graphics.GeometryContent) – The geometry which will recieve the normals.
• overwriteExistingNormals (bool) – Overwrite or skip over geometry with existing normals.

public void CalculateTangentFrames(MeshContent mesh, string textureCoordinateChannelName, string tangentChannelName, string binormalChannelName)

Generate the tangents and binormals (tangent frames) for each vertex in the mesh.

Parameters:

• mesh (Microsoft.Xna.Framework.Content.Pipeline.Graphics.MeshContent) – The mesh which will have add tangent and binormal channels added.
• textureCoordinateChannelName (string) – The Vector2 texture coordinate channel used to generate tangent frames.
• tangentChannelName (string) –
• binormalChannelName (string) –

public void CalculateTangentFrames(GeometryContent geom, string textureCoordinateChannelName, string tangentChannelName, string binormalChannelName)

Parameters:

• geom (Microsoft.Xna.Framework.Content.Pipeline.Graphics.GeometryContent) –
• textureCoordinateChannelName (string) –
• tangentChannelName (string) –
• binormalChannelName (string) –

public void CalculateTangentFrames(System.Collections.Generic.IList<Vector3> positions, System.Collections.Generic.IList<Int32> indices, System.Collections.Generic.IList<Vector3> normals, System.Collections.Generic.IList<Vector2> textureCoords, ref Microsoft.Xna.Framework.Vector3[] tangents, ref Microsoft.Xna.Framework.Vector3[] bitangents)

Parameters:

• positions (System.Collections.Generic.IList<Vector3>) –
• indices (System.Collections.Generic.IList<Int32>) –
• normals (System.Collections.Generic.IList<Vector3>) –
• textureCoords (System.Collections.Generic.IList<Vector2>) –
• (ref) tangents (Microsoft.Xna.Framework.Vector3[]) –
• (ref) bitangents (Microsoft.Xna.Framework.Vector3[]) –

public BoneContent FindSkeleton(NodeContent node)

Search for the root bone of the skeletion.

Parameters:

• node (Microsoft.Xna.Framework.Content.Pipeline.Graphics.NodeContent) – The node from which to begin the search for the skeleton.

Returns:

The root bone of the skeletion or null if none is found.

public System.Collections.Generic.IList<BoneContent> FlattenSkeleton(BoneContent skeleton)

Traverses a skeleton depth-first and builds a list of its bones.

Parameters:

• skeleton (Microsoft.Xna.Framework.Content.Pipeline.Graphics.BoneContent) –

public void MergeDuplicatePositions(MeshContent mesh, float tolerance)

Merge any positions in the T:Microsoft.Xna.Framework.Content.Pipeline.Graphics.PositionCollection of the specified mesh that are at a distance less than the specified tolerance from each other.

Parameters:

• mesh (Microsoft.Xna.Framework.Content.Pipeline.Graphics.MeshContent) – Mesh to be processed.
• tolerance (float) –

  Tolerance value that determines how close

  positions must be to each other to be merged.

public void MergeDuplicateVertices(GeometryContent geometry)

Merge vertices with the same P:Microsoft.Xna.Framework.Content.Pipeline.Graphics.VertexContent.PositionIndices and T:Microsoft.Xna.Framework.Content.Pipeline.Graphics.VertexChannel data within the specified T:Microsoft.Xna.Framework.Content.Pipeline.Graphics.GeometryContent.

Parameters:

• geometry (Microsoft.Xna.Framework.Content.Pipeline.Graphics.GeometryContent) – Geometry to be processed.

public void MergeDuplicateVertices(MeshContent mesh)

Merge vertices with the same P:Microsoft.Xna.Framework.Content.Pipeline.Graphics.VertexContent.PositionIndices and T:Microsoft.Xna.Framework.Content.Pipeline.Graphics.VertexChannel data within the P:Microsoft.Xna.Framework.Content.Pipeline.Graphics.MeshContent.Geometry of this mesh. If you want to merge positions too, call M:Microsoft.Xna.Framework.Content.Pipeline.Graphics.MeshHelper.MergeDuplicatePositions(Microsoft.Xna.Framework.Content.Pipeline.Graphics.MeshContent,System.Single) on your mesh before this function.

Parameters:

• mesh (Microsoft.Xna.Framework.Content.Pipeline.Graphics.MeshContent) – Mesh to be processed

public void OptimizeForCache(MeshContent mesh)

Parameters:

• mesh (Microsoft.Xna.Framework.Content.Pipeline.Graphics.MeshContent) –

public void SwapWindingOrder(MeshContent mesh)

Reverses the triangle winding order of the mesh.

Parameters:

• mesh (Microsoft.Xna.Framework.Content.Pipeline.Graphics.MeshContent) – The mesh which will be modified.

public void TransformScene(NodeContent scene, Matrix transform)

Transforms the contents of a node and its descendants.

Parameters:

• scene (Microsoft.Xna.Framework.Content.Pipeline.Graphics.NodeContent) – The root node of the scene to transform.
• transform (Microsoft.Xna.Framework.Matrix) – The transform matrix to apply to the scene.

bool IsLeftHanded(ref Matrix xform)

Parameters:

• (ref) xform (Microsoft.Xna.Framework.Matrix) –

MipmapChain

class MipmapChain : System.Collections.ObjectModel.Collection<BitmapContent>, System.Collections.Generic.IList<BitmapContent>, System.Collections.Generic.ICollection<BitmapContent>, System.Collections.Generic.IEnumerable<BitmapContent>, System.Collections.IEnumerable, System.Collections.IList, System.Collections.ICollection, System.Collections.Generic.IReadOnlyList<BitmapContent>, System.Collections.Generic.IReadOnlyCollection<BitmapContent>

Provides methods for accessing a mipmap chain.

public MipmapChain op_Implicit(BitmapContent bitmap)

Parameters:

• bitmap (Microsoft.Xna.Framework.Content.Pipeline.Graphics.BitmapContent) –

MipmapChainCollection

class MipmapChainCollection : System.Collections.ObjectModel.Collection<MipmapChain>, System.Collections.Generic.IList<MipmapChain>, System.Collections.Generic.ICollection<MipmapChain>, System.Collections.Generic.IEnumerable<MipmapChain>, System.Collections.IEnumerable, System.Collections.IList, System.Collections.ICollection, System.Collections.Generic.IReadOnlyList<MipmapChain>, System.Collections.Generic.IReadOnlyCollection<MipmapChain>

Provides methods for maintaining a mipmap chain.

ModelBoneContent

class ModelBoneContent : System.Object

readonly ModelBoneContentCollection Children

readonly int Index

readonly string Name

readonly ModelBoneContent Parent

Matrix Transform

void set_Children(ModelBoneContentCollection value)

Parameters:

• value (Microsoft.Xna.Framework.Content.Pipeline.Processors.ModelBoneContentCollection) –

ModelBoneContentCollection

class ModelBoneContentCollection : System.Collections.ObjectModel.ReadOnlyCollection<ModelBoneContent>, System.Collections.Generic.IList<ModelBoneContent>, System.Collections.Generic.ICollection<ModelBoneContent>, System.Collections.Generic.IEnumerable<ModelBoneContent>, System.Collections.IEnumerable, System.Collections.IList, System.Collections.ICollection, System.Collections.Generic.IReadOnlyList<ModelBoneContent>, System.Collections.Generic.IReadOnlyCollection<ModelBoneContent>

ModelContent

class ModelContent : System.Object

readonly ModelBoneContentCollection Bones

readonly ModelMeshContentCollection Meshes

readonly ModelBoneContent Root

System.Object Tag

ModelMeshContent

class ModelMeshContent : System.Object

readonly BoundingSphere BoundingSphere

readonly ModelMeshPartContentCollection MeshParts

readonly string Name

readonly ModelBoneContent ParentBone

readonly MeshContent SourceMesh

System.Object Tag

ModelMeshContentCollection

class ModelMeshContentCollection : System.Collections.ObjectModel.ReadOnlyCollection<ModelMeshContent>, System.Collections.Generic.IList<ModelMeshContent>, System.Collections.Generic.ICollection<ModelMeshContent>, System.Collections.Generic.IEnumerable<ModelMeshContent>, System.Collections.IEnumerable, System.Collections.IList, System.Collections.ICollection, System.Collections.Generic.IReadOnlyList<ModelMeshContent>, System.Collections.Generic.IReadOnlyCollection<ModelMeshContent>

ModelMeshPartContent

class ModelMeshPartContent : System.Object

readonly IndexCollection IndexBuffer

MaterialContent Material

readonly int NumVertices

readonly int PrimitiveCount

readonly int StartIndex

System.Object Tag

readonly VertexBufferContent VertexBuffer

readonly int VertexOffset

ModelMeshPartContentCollection

class ModelMeshPartContentCollection : System.Collections.ObjectModel.ReadOnlyCollection<ModelMeshPartContent>, System.Collections.Generic.IList<ModelMeshPartContent>, System.Collections.Generic.ICollection<ModelMeshPartContent>, System.Collections.Generic.IEnumerable<ModelMeshPartContent>, System.Collections.IEnumerable, System.Collections.IList, System.Collections.ICollection, System.Collections.Generic.IReadOnlyList<ModelMeshPartContent>, System.Collections.Generic.IReadOnlyCollection<ModelMeshPartContent>

ModelProcessor

class ModelProcessor : Microsoft.Xna.Framework.Content.Pipeline.ContentProcessor<NodeContent, ModelContent>, IContentProcessor

Color ColorKeyColor

bool ColorKeyEnabled

MaterialProcessorDefaultEffect DefaultEffect

bool GenerateMipmaps

bool GenerateTangentFrames

bool PremultiplyTextureAlpha

bool PremultiplyVertexColors

bool ResizeTexturesToPowerOfTwo

float RotationX

float RotationY

float RotationZ

float Scale

bool SwapWindingOrder

TextureProcessorOutputFormat TextureFormat

public ModelContent Process(NodeContent input, ContentProcessorContext context)

Parameters:

• input (Microsoft.Xna.Framework.Content.Pipeline.Graphics.NodeContent) –
• context (Microsoft.Xna.Framework.Content.Pipeline.ContentProcessorContext) –

Mp3Importer

class Mp3Importer : Microsoft.Xna.Framework.Content.Pipeline.ContentImporter<AudioContent>, IContentImporter

Provides methods for reading MP3 audio files for use in the Content Pipeline.

public AudioContent Import(string filename, ContentImporterContext context)

Called by the XNA Framework when importing an MP3 audio file to be used as a game asset. This is the method called by the XNA Framework when an asset is to be imported into an object that can be recognized by the Content Pipeline.

Parameters:

• filename (string) – Name of a game asset file.
• context (Microsoft.Xna.Framework.Content.Pipeline.ContentImporterContext) – Contains information for importing a game asset, such as a logger interface.

Returns:

Resulting game asset.

NamedValueDictionary<T>

class NamedValueDictionary<T> : System.Object, System.Collections.Generic.IDictionary<String, T>, System.Collections.Generic.ICollection<KeyValuePair`2>, System.Collections.Generic.IEnumerable<KeyValuePair`2>, System.Collections.IEnumerable

Type Parameters:  

• T –

readonly System.Collections.Generic.ICollection<String> Keys

Gets all keys contained in the dictionary.

readonly System.Collections.Generic.ICollection<T> Values

Gets all values contained in the dictionary.

Microsoft.Xna.Framework.Content.Pipeline.T Item

readonly int Count

Gets the number of items in the dictionary.

public void Add(string key, Microsoft.Xna.Framework.Content.Pipeline.T value)

Parameters:

• key (string) –
• value (Microsoft.Xna.Framework.Content.Pipeline.T) –

public bool ContainsKey(string key)

Determines whether the specified key is present in the dictionary.

Parameters:

• key (string) – Identity of a key.

Returns:

public bool Remove(string key)

Removes the specified key and value from the dictionary.

Parameters:

• key (string) – Identity of the key to be removed.

Returns:

true if the value is present; false otherwise.

public bool TryGetValue(string key, ref Microsoft.Xna.Framework.Content.Pipeline.T value)

Parameters:

• key (string) –
• (ref) value (Microsoft.Xna.Framework.Content.Pipeline.T) –

System.Type get_DefaultSerializerType()

public void Clear()

Removes all keys and values from the dictionary.

public System.Collections.Generic.IEnumerator<KeyValuePair`2> GetEnumerator()

Gets an enumerator that iterates through items in a dictionary.

Returns:Enumerator for iterating through the dictionary.

NodeContent

class NodeContent : ContentItem

Provides a base class for graphics types that define local coordinate systems.

readonly Matrix AbsoluteTransform

Gets the value of the local Transform property, multiplied by the AbsoluteTransform of the parent.

readonly AnimationContentDictionary Animations

Gets the set of animations belonging to this node.

readonly NodeContentCollection Children

Gets the children of the NodeContent object.

NodeContent Parent

Gets the parent of this NodeContent object.

Matrix Transform

Gets the transform matrix of the scene. The transform matrix defines a local coordinate system for the content in addition to any children of this object.

NodeContentCollection

class NodeContentCollection : Microsoft.Xna.Framework.Content.Pipeline.ChildCollection<NodeContent, NodeContent>, System.Collections.Generic.IList<NodeContent>, System.Collections.Generic.ICollection<NodeContent>, System.Collections.Generic.IEnumerable<NodeContent>, System.Collections.IEnumerable, System.Collections.IList, System.Collections.ICollection, System.Collections.Generic.IReadOnlyList<NodeContent>, System.Collections.Generic.IReadOnlyCollection<NodeContent>

OggImporter

class OggImporter : Microsoft.Xna.Framework.Content.Pipeline.ContentImporter<AudioContent>, IContentImporter

Provides methods for reading .ogg audio files for use in the Content Pipeline.

public AudioContent Import(string filename, ContentImporterContext context)

Called by the XNA Framework when importing an ogg audio file to be used as a game asset. This is the method called by the XNA Framework when an asset is to be imported into an object that can be recognized by the Content Pipeline.

Parameters:

• filename (string) – Name of a game asset file.
• context (Microsoft.Xna.Framework.Content.Pipeline.ContentImporterContext) – Contains information for importing a game asset, such as a logger interface.

Returns:

Resulting game asset.

OpaqueDataDictionary

class OpaqueDataDictionary : Microsoft.Xna.Framework.Content.Pipeline.NamedValueDictionary<Object>, System.Collections.Generic.IDictionary<String, Object>, System.Collections.Generic.ICollection<KeyValuePair`2>, System.Collections.Generic.IEnumerable<KeyValuePair`2>, System.Collections.IEnumerable

OpenAssetImporter

class OpenAssetImporter : Microsoft.Xna.Framework.Content.Pipeline.ContentImporter<NodeContent>, IContentImporter

string ImporterName

public NodeContent Import(string filename, ContentImporterContext context)

Parameters:

• filename (string) –
• context (Microsoft.Xna.Framework.Content.Pipeline.ContentImporterContext) –

public Matrix ToXna(Assimp.Matrix4x4 matrix)

Parameters:

• matrix (Assimp.Matrix4x4) –

public Vector2 ToXna(Assimp.Vector2D vector)

Parameters:

• vector (Assimp.Vector2D) –

public Vector3 ToXna(Assimp.Vector3D vector)

Parameters:

• vector (Assimp.Vector3D) –

public Quaternion ToXna(Assimp.Quaternion quaternion)

Parameters:

• quaternion (Assimp.Quaternion) –

public Vector3 ToXna(Assimp.Color4D color)

Parameters:

• color (Assimp.Color4D) –

public Vector2 ToXnaTexCoord(Assimp.Vector3D vector)

Parameters:

• vector (Assimp.Vector3D) –

public Color ToXnaColor(Assimp.Color4D color)

Parameters:

• color (Assimp.Color4D) –

Options

class Options : System.Object

string SourceFile

string OutputFile

ShaderProfile Profile

bool Debug

string Defines

ParseError

class ParseError : System.Object

readonly string File

readonly int Code

readonly int Line

readonly int Column

readonly int Position

readonly int Length

readonly string Message

ParseErrors

class ParseErrors : System.Collections.Generic.List<ParseError>, System.Collections.Generic.IList<ParseError>, System.Collections.Generic.ICollection<ParseError>, System.Collections.Generic.IEnumerable<ParseError>, System.Collections.IEnumerable, System.Collections.IList, System.Collections.ICollection, System.Collections.Generic.IReadOnlyList<ParseError>, System.Collections.Generic.IReadOnlyCollection<ParseError>

ParseNode

class ParseNode : System.Object

ParseNode Parent

Token Token

readonly System.Collections.Generic.List<ParseNode> Nodes

string Text

public ParseNode CreateNode(Token token, string text)

Parameters:

• token (TwoMGFX.Token) –
• text (string) –

System.Object Eval(ParseTree tree, System.Object[] paramlist)

this implements the evaluation functionality, cannot be used directly

Parameters:

• tree (TwoMGFX.ParseTree) – the parsetree itself
• paramlist (System.Object[]) – optional input parameters

Returns:

a partial result of the evaluation

Parser

class Parser : System.Object

public ParseTree Parse(string input)

Parameters:

• input (string) –

public ParseTree Parse(string input, string fileName)

Parameters:

• input (string) –
• fileName (string) –

public ParseTree Parse(string input, string fileName, ParseTree tree)

Parameters:

• input (string) –
• fileName (string) –
• tree (TwoMGFX.ParseTree) –

ParseTree

class ParseTree : ParseNode

ParseErrors Errors

System.Collections.Generic.List<Token> Skipped

public string PrintTree()

public System.Object Eval(System.Object[] paramlist)

this is the entry point for executing and evaluating the parse tree.

Parameters:

• paramlist (System.Object[]) – additional optional input parameters

Returns:

the output of the evaluation function

ParseTreeTools

class ParseTreeTools : System.Object

public float ParseFloat(string value)

Parameters:

• value (string) –

public int ParseInt(string value)

Parameters:

• value (string) –

public bool ParseBool(string value)

Parameters:

• value (string) –

public Color ParseColor(string value)

Parameters:

• value (string) –

public void WhitespaceNodes(TokenType type, System.Collections.Generic.List<ParseNode> nodes, ref string sourceFile)

Parameters:

• type (TwoMGFX.TokenType) –
• nodes (System.Collections.Generic.List<ParseNode>) –
• (ref) sourceFile (string) –

PassInfo

class PassInfo : System.Object

string name

string vsModel

string vsFunction

string psModel

string psFunction

BlendState blendState

RasterizerState rasterizerState

DepthStencilState depthStencilState

PassThroughProcessor

class PassThroughProcessor : Microsoft.Xna.Framework.Content.Pipeline.ContentProcessor<Object, Object>, IContentProcessor

As the name implies, this processor simply passes data through as-is.

public System.Object Process(System.Object input, ContentProcessorContext context)

Parameters:

• input (System.Object) –
• context (Microsoft.Xna.Framework.Content.Pipeline.ContentProcessorContext) –

PathHelper

class PathHelper : System.Object

char DirectorySeparator

The/universal/standard/directory/seperator.

public string Normalize(string path)

Returns a path string normalized to the/universal/standard.

Parameters:

• path (string) –

public string NormalizeDirectory(string path)

Returns a directory path string normalized to the/universal/standard with a trailing seperator.

Parameters:

• path (string) –

public string NormalizeWindows(string path)

Returns a path string normalized to theWindowsstandard.

Parameters:

• path (string) –

public string GetRelativePath(string basePath, string path)

Returns a path relative to the base path.

Parameters:

• basePath (string) – The path to make relative to. Must end with directory seperator.
• path (string) – The path to be made relative to the basePath.

Returns:

The relative path or the original string if it is not absolute or cannot be made relative.

PipelineBuildEvent

class PipelineBuildEvent : System.Object

string Extension

string SourceFile

Absolute path to the source file.

System.DateTime SourceTime

The date/time stamp of the source file.

string DestFile

Absolute path to the output file.

System.DateTime DestTime

The date/time stamp of the destination file.

string Importer

System.DateTime ImporterTime

The date/time stamp of the DLL containing the importer.

string Processor

System.DateTime ProcessorTime

The date/time stamp of the DLL containing the processor.

OpaqueDataDictionary Parameters

System.Collections.Generic.List<Pair> ParametersXml

System.Collections.Generic.List<String> Dependencies

Gets or sets the dependencies.

Value:The dependencies.

System.Collections.Generic.List<String> BuildAsset

Gets or sets the additional (nested) assets.

Value:The additional (nested) assets.

System.Collections.Generic.List<String> BuildOutput

Gets or sets the related output files.

Value:The related output files.

public PipelineBuildEvent Load(string filePath)

Parameters:

• filePath (string) –

public void Save(string filePath)

Parameters:

• filePath (string) –

public bool NeedsRebuild(PipelineManager manager, PipelineBuildEvent cachedEvent)

Parameters:

• manager (MonoGame.Framework.Content.Pipeline.Builder.PipelineManager) –
• cachedEvent (MonoGame.Framework.Content.Pipeline.Builder.PipelineBuildEvent) –

bool AreParametersEqual(OpaqueDataDictionary parameters0, OpaqueDataDictionary parameters1, OpaqueDataDictionary defaultValues)

Parameters:

• parameters0 (Microsoft.Xna.Framework.Content.Pipeline.OpaqueDataDictionary) –
• parameters1 (Microsoft.Xna.Framework.Content.Pipeline.OpaqueDataDictionary) –
• defaultValues (Microsoft.Xna.Framework.Content.Pipeline.OpaqueDataDictionary) –

PipelineBuildLogger

class PipelineBuildLogger : ContentBuildLogger

public void LogMessage(string message, System.Object[] messageArgs)

Parameters:

• message (string) –
• messageArgs (System.Object[]) –

public void LogImportantMessage(string message, System.Object[] messageArgs)

Parameters:

• message (string) –
• messageArgs (System.Object[]) –

public void LogWarning(string helpLink, ContentIdentity contentIdentity, string message, System.Object[] messageArgs)

Parameters:

• helpLink (string) –
• contentIdentity (Microsoft.Xna.Framework.Content.Pipeline.ContentIdentity) –
• message (string) –
• messageArgs (System.Object[]) –

PipelineComponentScanner

class PipelineComponentScanner : System.Object

Implements a scanner object containing the available importers and processors for an application. Designed for internal use only.

readonly System.Collections.Generic.IList<String> Errors

Gets the list of error messages produced by the last call to Update.

readonly System.Collections.Generic.IDictionary<String, ContentImporterAttribute> ImporterAttributes

Gets a dictionary that maps importer names to their associated metadata attributes.

readonly System.Collections.Generic.IEnumerable<String> ImporterNames

Gets the names of all available importers.

readonly System.Collections.Generic.IDictionary<String, String> ImporterOutputTypes

Gets a dictionary that maps importer names to the fully qualified name of their return types.

readonly System.Collections.Generic.IDictionary<String, ContentProcessorAttribute> ProcessorAttributes

Gets a dictionary that maps processor names to their associated metadata attributes.

readonly System.Collections.Generic.IDictionary<String, String> ProcessorInputTypes

Gets a dictionary that maps processor names to the fully qualified name of supported input types.

readonly System.Collections.Generic.IEnumerable<String> ProcessorNames

Gets the names of all available processors.

readonly System.Collections.Generic.IDictionary<String, String> ProcessorOutputTypes

Gets a dictionary that maps processor names to the fully qualified name of their output types.

readonly System.Collections.Generic.IDictionary<String, ProcessorParameterCollection> ProcessorParameters

A collection of supported processor parameters.

public bool Update(System.Collections.Generic.IEnumerable<String> pipelineAssemblies)

Updates the scanner object with the latest available assembly states.

Parameters:

• pipelineAssemblies (System.Collections.Generic.IEnumerable<String>) – Enumerated list of available assemblies.

Returns:

true if an actual scan was required, indicating the collection contents may have changed. false if no assembly changes were detected since the previous call.

public bool Update(System.Collections.Generic.IEnumerable<String> pipelineAssemblies, System.Collections.Generic.IEnumerable<String> pipelineAssemblyDependencies)

Updates the scanner object with the latest available assembly states.

Parameters:

• pipelineAssemblies (System.Collections.Generic.IEnumerable<String>) – Enumerated list of available assemblies.
• pipelineAssemblyDependencies (System.Collections.Generic.IEnumerable<String>) – Enumerated list of dependent assemblies.

Returns:

true if an actual scan was required, indicating the collection contents may have changed. false if no assembly changes were detected since the previous call.

PipelineException

class PipelineException : System.Exception, System.Runtime.Serialization.ISerializable, System.Runtime.InteropServices._Exception

Thrown when errors are encountered during a content pipeline build.

PipelineImporterContext

class PipelineImporterContext : ContentImporterContext

readonly string IntermediateDirectory

readonly string OutputDirectory

readonly ContentBuildLogger Logger

public void AddDependency(string filename)

Parameters:

• filename (string) –

PipelineManager

class PipelineManager : System.Object

readonly string ProjectDirectory

readonly string OutputDirectory

readonly string IntermediateDirectory

ContentBuildLogger Logger

readonly System.Collections.Generic.List<String> Assemblies

GraphicsProfile Profile

The current target graphics profile for which all content is built.

TargetPlatform Platform

The current target platform for which all content is built.

string Config

The build configuration passed thru to content processors.

bool CompressContent

Gets or sets if the content is compressed.

bool RethrowExceptions

If true exceptions thrown from within an importer or processor are caught and then thrown from the context. Default value is true.

public void AssignTypeConverter<TType, TTypeConverter>()

Type Parameters:  

• TType –
• TTypeConverter –

public void AddAssembly(string assemblyFilePath)

Parameters:

• assemblyFilePath (string) –

public System.Type[] GetImporterTypes()

public System.Type[] GetProcessorTypes()

public IContentImporter CreateImporter(string name)

Parameters:

• name (string) –

public string FindImporterByExtension(string ext)

Parameters:

• ext (string) –

public System.DateTime GetImporterAssemblyTimestamp(string name)

Parameters:

• name (string) –

public string FindDefaultProcessor(string importer)

Parameters:

• importer (string) –

public System.Type GetProcessorType(string name)

Parameters:

• name (string) –

public void ResolveImporterAndProcessor(string sourceFilepath, ref string importerName, ref string processorName)

Parameters:

• sourceFilepath (string) –
• (ref) importerName (string) –
• (ref) processorName (string) –

public IContentProcessor CreateProcessor(string name, OpaqueDataDictionary processorParameters)

Parameters:

• name (string) –
• processorParameters (Microsoft.Xna.Framework.Content.Pipeline.OpaqueDataDictionary) –

public OpaqueDataDictionary GetProcessorDefaultValues(string processorName)

Gets the default values for the content processor parameters.

Parameters:

• processorName (string) – The name of the content processor.

Returns:

A dictionary containing the default value for each parameter. Returns :ref:`` if the content processor has not been created yet.

public System.DateTime GetProcessorAssemblyTimestamp(string name)

Parameters:

• name (string) –

public OpaqueDataDictionary ValidateProcessorParameters(string name, OpaqueDataDictionary processorParameters)

Parameters:

• name (string) –
• processorParameters (Microsoft.Xna.Framework.Content.Pipeline.OpaqueDataDictionary) –

public void RegisterContent(string sourceFilepath, string outputFilepath, string importerName, string processorName, OpaqueDataDictionary processorParameters)

Parameters:

• sourceFilepath (string) –
• outputFilepath (string) –
• importerName (string) –
• processorName (string) –
• processorParameters (Microsoft.Xna.Framework.Content.Pipeline.OpaqueDataDictionary) –

public PipelineBuildEvent BuildContent(string sourceFilepath, string outputFilepath, string importerName, string processorName, OpaqueDataDictionary processorParameters)

Parameters:

• sourceFilepath (string) –
• outputFilepath (string) –
• importerName (string) –
• processorName (string) –
• processorParameters (Microsoft.Xna.Framework.Content.Pipeline.OpaqueDataDictionary) –

public System.Object ProcessContent(PipelineBuildEvent pipelineEvent)

Parameters:

• pipelineEvent (MonoGame.Framework.Content.Pipeline.Builder.PipelineBuildEvent) –

public void CleanContent(string sourceFilepath, string outputFilepath)

Parameters:

• sourceFilepath (string) –
• outputFilepath (string) –

public string GetAssetName(string sourceFileName, string importerName, string processorName, OpaqueDataDictionary processorParameters)

Gets an automatic asset name, such as “AssetName_0”.

Parameters:

• sourceFileName (string) – The source file name.
• importerName (string) – The name of the content importer. Can be :ref:``.
• processorName (string) – The name of the content processor. Can be :ref:``.
• processorParameters (Microsoft.Xna.Framework.Content.Pipeline.OpaqueDataDictionary) – The processor parameters. Can be :ref:``.

Returns:

The asset name.

PipelineProcessorContext

class PipelineProcessorContext : ContentProcessorContext

readonly TargetPlatform TargetPlatform

readonly GraphicsProfile TargetProfile

readonly string BuildConfiguration

readonly string IntermediateDirectory

readonly string OutputDirectory

readonly string OutputFilename

readonly OpaqueDataDictionary Parameters

readonly ContentBuildLogger Logger

public void AddDependency(string filename)

Parameters:

• filename (string) –

public void AddOutputFile(string filename)

Parameters:

• filename (string) –

public MonoGame.Framework.Content.Pipeline.Builder.TOutput Convert<TInput, TOutput>(MonoGame.Framework.Content.Pipeline.Builder.TInput input, string processorName, OpaqueDataDictionary processorParameters)

Type Parameters:  

• TInput –
• TOutput –

Parameters:

• input (MonoGame.Framework.Content.Pipeline.Builder.TInput) –
• processorName (string) –
• processorParameters (Microsoft.Xna.Framework.Content.Pipeline.OpaqueDataDictionary) –

public MonoGame.Framework.Content.Pipeline.Builder.TOutput BuildAndLoadAsset<TInput, TOutput>(Microsoft.Xna.Framework.Content.Pipeline.ExternalReference<TInput> sourceAsset, string processorName, OpaqueDataDictionary processorParameters, string importerName)

Type Parameters:  

• TInput –
• TOutput –

Parameters:

• sourceAsset (Microsoft.Xna.Framework.Content.Pipeline.ExternalReference<TInput>) –
• processorName (string) –
• processorParameters (Microsoft.Xna.Framework.Content.Pipeline.OpaqueDataDictionary) –
• importerName (string) –

public Microsoft.Xna.Framework.Content.Pipeline.ExternalReference<TOutput> BuildAsset<TInput, TOutput>(Microsoft.Xna.Framework.Content.Pipeline.ExternalReference<TInput> sourceAsset, string processorName, OpaqueDataDictionary processorParameters, string importerName, string assetName)

Type Parameters:  

• TInput –
• TOutput –

Parameters:

• sourceAsset (Microsoft.Xna.Framework.Content.Pipeline.ExternalReference<TInput>) –
• processorName (string) –
• processorParameters (Microsoft.Xna.Framework.Content.Pipeline.OpaqueDataDictionary) –
• importerName (string) –
• assetName (string) –

PixelBitmapContent<T>

class PixelBitmapContent<T> : BitmapContent

Type Parameters:  

• T –

public System.Byte[] GetPixelData()

public void SetPixelData(System.Byte[] sourceData)

Parameters:

• sourceData (System.Byte[]) –

public Microsoft.Xna.Framework.Content.Pipeline.Graphics.T[] GetRow(int y)

Parameters:

• y (int) –

public bool TryGetFormat(ref SurfaceFormat format)

Parameters:

• (ref) format (Microsoft.Xna.Framework.Graphics.SurfaceFormat) –

public Microsoft.Xna.Framework.Content.Pipeline.Graphics.T GetPixel(int x, int y)

Parameters:

• x (int) –
• y (int) –

public void SetPixel(int x, int y, Microsoft.Xna.Framework.Content.Pipeline.Graphics.T value)

Parameters:

• x (int) –
• y (int) –
• value (Microsoft.Xna.Framework.Content.Pipeline.Graphics.T) –

public void ReplaceColor(Microsoft.Xna.Framework.Content.Pipeline.Graphics.T originalColor, Microsoft.Xna.Framework.Content.Pipeline.Graphics.T newColor)

Parameters:

• originalColor (Microsoft.Xna.Framework.Content.Pipeline.Graphics.T) –
• newColor (Microsoft.Xna.Framework.Content.Pipeline.Graphics.T) –

PositionCollection

class PositionCollection : System.Collections.ObjectModel.Collection<Vector3>, System.Collections.Generic.IList<Vector3>, System.Collections.Generic.ICollection<Vector3>, System.Collections.Generic.IEnumerable<Vector3>, System.Collections.IEnumerable, System.Collections.IList, System.Collections.ICollection, System.Collections.Generic.IReadOnlyList<Vector3>, System.Collections.Generic.IReadOnlyCollection<Vector3>

Provides a collection of vertex position values.

Preprocessor

class Preprocessor : System.Object

public string Preprocess(string effectCode, string filePath, System.Collections.Generic.IDictionary<String, String> defines, System.Collections.Generic.List<String> dependencies, IEffectCompilerOutput output)

Parameters:

• effectCode (string) –
• filePath (string) –
• String> defines (System.Collections.Generic.IDictionary<String,) –
• dependencies (System.Collections.Generic.List<String>) –
• output (TwoMGFX.IEffectCompilerOutput) –

ProcessorParameter

class ProcessorParameter : System.Object

Represents a processor parameter. Processor parameters are automatically discovered by the content pipeline. Therefore, only custom processor developers should use this class directly.

System.Object DefaultValue

Default value of the processor parameter.

string Description

Description of the parameter, as specified by the [Description] attribute.

string DisplayName

Name of the parameter displayed in the designer, as specified by the [DisplayName] attribute.

readonly bool IsEnum

Gets a value indicating whether the parameter is an enumeration.

readonly System.Collections.ObjectModel.ReadOnlyCollection<String> PossibleEnumValues

Available options for enumerated type parameters. For parameters of other types, this value is null.

readonly string PropertyName

Name of the property, as defined in the C# code.

readonly string PropertyType

Type of the parameter.

ProcessorParameterCollection

class ProcessorParameterCollection : System.Collections.ObjectModel.ReadOnlyCollection<ProcessorParameter>, System.Collections.Generic.IList<ProcessorParameter>, System.Collections.Generic.ICollection<ProcessorParameter>, System.Collections.Generic.IEnumerable<ProcessorParameter>, System.Collections.IEnumerable, System.Collections.IList, System.Collections.ICollection, System.Collections.Generic.IReadOnlyList<ProcessorParameter>, System.Collections.Generic.IReadOnlyCollection<ProcessorParameter>

Represents a collection of processor parameters, usually for a single processor. This class is primarily designed for internal use or for custom processor developers.

PvrtcBitmapContent

class PvrtcBitmapContent : BitmapContent

public System.Byte[] GetPixelData()

public void SetPixelData(System.Byte[] sourceData)

Parameters:

• sourceData (System.Byte[]) –

PvrtcRgb2BitmapContent

class PvrtcRgb2BitmapContent : PvrtcBitmapContent

public bool TryGetFormat(ref SurfaceFormat format)

Parameters:

• (ref) format (Microsoft.Xna.Framework.Graphics.SurfaceFormat) –

public string ToString()

Returns a string description of the bitmap.

Returns:Description of the bitmap.

PvrtcRgb4BitmapContent

class PvrtcRgb4BitmapContent : PvrtcBitmapContent

public bool TryGetFormat(ref SurfaceFormat format)

Parameters:

• (ref) format (Microsoft.Xna.Framework.Graphics.SurfaceFormat) –

public string ToString()

Returns a string description of the bitmap.

Returns:Description of the bitmap.

PvrtcRgba2BitmapContent

class PvrtcRgba2BitmapContent : PvrtcBitmapContent

public bool TryGetFormat(ref SurfaceFormat format)

Parameters:

• (ref) format (Microsoft.Xna.Framework.Graphics.SurfaceFormat) –

public string ToString()

Returns a string description of the bitmap.

Returns:Description of the bitmap.

PvrtcRgba4BitmapContent

class PvrtcRgba4BitmapContent : PvrtcBitmapContent

public bool TryGetFormat(ref SurfaceFormat format)

Parameters:

• (ref) format (Microsoft.Xna.Framework.Graphics.SurfaceFormat) –

public string ToString()

Returns a string description of the bitmap.

Returns:Description of the bitmap.

SamplerStateInfo

class SamplerStateInfo : System.Object

string Name

string TextureName

readonly SamplerState State

Scanner

class Scanner : System.Object

string Input

int StartPos

int EndPos

string CurrentFile

int CurrentLine

int CurrentColumn

int CurrentPosition

System.Collections.Generic.List<Token> Skipped

System.Collections.Generic.Dictionary<TokenType, Regex> Patterns

public void Init(string input)

Parameters:

• input (string) –

public void Init(string input, string fileName)

Parameters:

• input (string) –
• fileName (string) –

public Token GetToken(TokenType type)

Parameters:

• type (TwoMGFX.TokenType) –

public Token Scan(TwoMGFX.TokenType[] expectedtokens)

executes a lookahead of the next token and will advance the scan on the input string

Parameters:

• expectedtokens (TwoMGFX.TokenType[]) –

Returns:

public Token LookAhead(TwoMGFX.TokenType[] expectedtokens)

returns token with longest best match

Parameters:

• expectedtokens (TwoMGFX.TokenType[]) –

Returns:

ShaderCompilerException

class ShaderCompilerException : System.Exception, System.Runtime.Serialization.ISerializable, System.Runtime.InteropServices._Exception

ShaderInfo

class ShaderInfo : System.Object

System.Collections.Generic.List<TechniqueInfo> Techniques

System.Collections.Generic.Dictionary<String, SamplerStateInfo> SamplerStates

readonly string FilePath

readonly string FileContent

readonly ShaderProfile Profile

readonly string OutputFilePath

readonly bool Debug

readonly System.Collections.Generic.List<String> Dependencies

readonly System.Collections.Generic.List<String> AdditionalOutputFiles

public ShaderInfo FromFile(string path, Options options, IEffectCompilerOutput output)

Parameters:

• path (string) –
• options (TwoMGFX.Options) –
• output (TwoMGFX.IEffectCompilerOutput) –

public ShaderInfo FromString(string effectSource, string filePath, Options options, IEffectCompilerOutput output)

Parameters:

• effectSource (string) –
• filePath (string) –
• options (TwoMGFX.Options) –
• output (TwoMGFX.IEffectCompilerOutput) –

ShaderProfile

class ShaderProfile : System.Object

ShaderProfile OpenGL

ShaderProfile DirectX_11

readonly System.Collections.Generic.IEnumerable<ShaderProfile> All

Returns all the loaded shader profiles.

readonly string Name

Returns the name of the shader profile.

readonly byte FormatId

Returns the format identifier used in the MGFX file format.

public ShaderProfile ForPlatform(string platform)

Returns the correct profile for the named platform or null if no supporting profile is found.

Parameters:

• platform (string) –

public ShaderProfile FromName(string name)

Returns the profile by name or null if no match is found.

Parameters:

• name (string) –

abstract void AddMacros(System.Collections.Generic.Dictionary<String, String> macros)

Parameters:

• String> macros (System.Collections.Generic.Dictionary<String,) –

abstract void ValidateShaderModels(PassInfo pass)

Parameters:

• pass (TwoMGFX.PassInfo) –

abstract TwoMGFX.ShaderData CreateShader(ShaderInfo shaderInfo, string shaderFunction, string shaderProfile, bool isVertexShader, TwoMGFX.EffectObject effect, ref string errorsAndWarnings)

Parameters:

• shaderInfo (TwoMGFX.ShaderInfo) –
• shaderFunction (string) –
• shaderProfile (string) –
• isVertexShader (bool) –
• effect (TwoMGFX.EffectObject) –
• (ref) errorsAndWarnings (string) –

abstract bool Supports(string platform)

Parameters:

• platform (string) –

SkinnedMaterialContent

class SkinnedMaterialContent : MaterialContent

string AlphaKey

string DiffuseColorKey

string EmissiveColorKey

string SpecularColorKey

string SpecularPowerKey

string TextureKey

string WeightsPerVertexKey

System.Nullable<Single> Alpha

System.Nullable<Vector3> DiffuseColor

System.Nullable<Vector3> EmissiveColor

System.Nullable<Vector3> SpecularColor

System.Nullable<Single> SpecularPower

Microsoft.Xna.Framework.Content.Pipeline.ExternalReference<TextureContent> Texture

System.Nullable<Int32> WeightsPerVertex

SongContent

class SongContent : System.Object

Represents a processed Song object.

SongProcessor

class SongProcessor : Microsoft.Xna.Framework.Content.Pipeline.ContentProcessor<AudioContent, SongContent>, IContentProcessor

A custom song processor that processes an intermediate AudioContent type. This type encapsulates the source audio content, producing a Song type that can be used in the game.

ConversionQuality Quality

Gets or sets the target format quality of the audio content.

Value:The ConversionQuality of this audio data.

public SongContent Process(AudioContent input, ContentProcessorContext context)

Builds the content for the source audio.

Parameters:

• input (Microsoft.Xna.Framework.Content.Pipeline.Audio.AudioContent) – The audio content to build.
• context (Microsoft.Xna.Framework.Content.Pipeline.ContentProcessorContext) – Context for the specified processor.

Returns:

The built audio.

SoundEffectContent

class SoundEffectContent : System.Object

Represents a processed sound effect.

SoundEffectProcessor

class SoundEffectProcessor : Microsoft.Xna.Framework.Content.Pipeline.ContentProcessor<AudioContent, SoundEffectContent>, IContentProcessor

A sound effect processor that processes an intermediate AudioContent type. This type encapsulates the source audio content, producing a SoundEffect type that can be used in the game.

ConversionQuality Quality

Gets or sets the target format quality of the audio content.

Value:The ConversionQuality of this audio data.

public SoundEffectContent Process(AudioContent input, ContentProcessorContext context)

Builds the content for the source audio.

Parameters:

• input (Microsoft.Xna.Framework.Content.Pipeline.Audio.AudioContent) – The audio content to build.
• context (Microsoft.Xna.Framework.Content.Pipeline.ContentProcessorContext) – Context for the specified processor.

Returns:

The built audio.

SpriteFontContent

class SpriteFontContent : System.Object

string FontName

float FontSize

Texture2DContent Texture

System.Collections.Generic.List<Rectangle> Glyphs

System.Collections.Generic.List<Rectangle> Cropping

System.Collections.Generic.List<Char> CharacterMap

int VerticalLineSpacing

float HorizontalSpacing

System.Collections.Generic.List<Vector3> Kerning

System.Nullable<Char> DefaultCharacter

SpriteFontContentWriter

class SpriteFontContentWriter : Microsoft.Xna.Framework.Content.Pipeline.Serialization.Compiler.ContentTypeWriter<SpriteFontContent>

void Write(ContentWriter output, SpriteFontContent value)

Parameters:

• output (Microsoft.Xna.Framework.Content.Pipeline.Serialization.Compiler.ContentWriter) –
• value (Microsoft.Xna.Framework.Content.Pipeline.Graphics.SpriteFontContent) –

public string GetRuntimeReader(TargetPlatform targetPlatform)

Gets the assembly qualified name of the runtime loader for this type.

Parameters:

• targetPlatform (Microsoft.Xna.Framework.Content.Pipeline.TargetPlatform) – Name of the platform.

Returns:

Name of the runtime loader.

public string GetRuntimeType(TargetPlatform targetPlatform)

Gets the assembly qualified name of the runtime target type. The runtime target type often matches the design time type, but may differ.

Parameters:

• targetPlatform (Microsoft.Xna.Framework.Content.Pipeline.TargetPlatform) – The target platform.

Returns:

The qualified name.

bool ShouldCompressContent(TargetPlatform targetPlatform, System.Object value)

Indicates whether a given type of content should be compressed.

Parameters:

• targetPlatform (Microsoft.Xna.Framework.Content.Pipeline.TargetPlatform) – The target platform of the content build.
• value (System.Object) – The object about to be serialized, or null if a collection of objects is to be serialized.

Returns:

true if the content of the requested type should be compressed; false otherwise.

StringToColorConverter

class StringToColorConverter : System.ComponentModel.TypeConverter

public bool CanConvertTo(System.ComponentModel.ITypeDescriptorContext context, System.Type destinationType)

Parameters:

• context (System.ComponentModel.ITypeDescriptorContext) –
• destinationType (System.Type) –

public System.Object ConvertTo(System.ComponentModel.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, System.Object value, System.Type destinationType)

Parameters:

• context (System.ComponentModel.ITypeDescriptorContext) –
• culture (System.Globalization.CultureInfo) –
• value (System.Object) –
• destinationType (System.Type) –

public bool CanConvertFrom(System.ComponentModel.ITypeDescriptorContext context, System.Type sourceType)

Parameters:

• context (System.ComponentModel.ITypeDescriptorContext) –
• sourceType (System.Type) –

public System.Object ConvertFrom(System.ComponentModel.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, System.Object value)

Parameters:

• context (System.ComponentModel.ITypeDescriptorContext) –
• culture (System.Globalization.CultureInfo) –
• value (System.Object) –

TargetPlatform

enum TargetPlatform : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Identifiers for the target platform.

TargetPlatform Windows

All desktop versions of Windows using DirectX.

TargetPlatform Xbox360

Xbox 360 video game and entertainment system

TargetPlatform iOS

Apple iOS-based devices (iPod Touch, iPhone, iPad) (MonoGame)

TargetPlatform Android

Android-based devices (MonoGame)

TargetPlatform DesktopGL

All desktop versions using OpenGL. (MonoGame)

TargetPlatform MacOSX

Apple Mac OSX-based devices (iMac, MacBook, MacBook Air, etc) (MonoGame)

TargetPlatform WindowsStoreApp

Windows Store App (MonoGame)

TargetPlatform NativeClient

Google Chrome Native Client (MonoGame)

TargetPlatform PlayStationMobile

Sony PlayStation Mobile (PS Vita) (MonoGame)

TargetPlatform WindowsPhone8

Windows Phone 8 (MonoGame)

TargetPlatform RaspberryPi

Raspberry Pi (MonoGame)

TargetPlatform PlayStation4

Sony PlayStation4

TargetPlatform PSVita

PlayStation Vita

TargetPlatform XboxOne

Xbox One

TechniqueInfo

class TechniqueInfo : System.Object

int startPos

int length

string name

System.Collections.Generic.List<PassInfo> Passes

Texture2DContent

class Texture2DContent : TextureContent

MipmapChain Mipmaps

public void Validate(System.Nullable<GraphicsProfile> targetProf)

Parameters:

• targetProf (System.Nullable<GraphicsProfile>) –

Texture3DContent

class Texture3DContent : TextureContent

public void Validate(System.Nullable<GraphicsProfile> targetProf)

Parameters:

• targetProf (System.Nullable<GraphicsProfile>) –

public void GenerateMipmaps(bool overwriteExistingMipmaps)

Parameters:

• overwriteExistingMipmaps (bool) –

TextureContent

class TextureContent : ContentItem

Provides a base class for all texture objects.

readonly MipmapChainCollection Faces

Collection of image faces that hold a single mipmap chain for a regular 2D texture, six chains for a cube map, or an arbitrary number for volume and array textures.

public void ConvertBitmapType(System.Type newBitmapType)

Converts all bitmaps for this texture to a different format.

Parameters:

• newBitmapType (System.Type) – Type being converted to. The new type must be a subclass of BitmapContent, such as PixelBitmapContent or DxtBitmapContent.

public void GenerateMipmaps(bool overwriteExistingMipmaps)

Generates a full set of mipmaps for the texture.

Parameters:

• overwriteExistingMipmaps (bool) – true if the existing mipmap set is replaced with the new set; false otherwise.

public abstract void Validate(System.Nullable<GraphicsProfile> targetProfile)

Verifies that all contents of this texture are present, correct and match the capabilities of the device.

Parameters:

• targetProfile (System.Nullable<GraphicsProfile>) – The profile identifier that defines the capabilities of the device.

TextureCubeContent

class TextureCubeContent : TextureContent

public void Validate(System.Nullable<GraphicsProfile> targetProf)

Parameters:

• targetProf (System.Nullable<GraphicsProfile>) –

TextureFilterType

enum TextureFilterType : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

TextureFilterType None

TextureFilterType Point

TextureFilterType Linear

TextureFilterType Anisotropic

TextureImporter

class TextureImporter : Microsoft.Xna.Framework.Content.Pipeline.ContentImporter<TextureContent>, IContentImporter

Provides methods for reading texture files for use in the Content Pipeline.

public TextureContent Import(string filename, ContentImporterContext context)

Called by the XNA Framework when importing a texture file to be used as a game asset. This is the method called by the XNA Framework when an asset is to be imported into an object that can be recognized by the Content Pipeline.

Parameters:

• filename (string) – Name of a game asset file.
• context (Microsoft.Xna.Framework.Content.Pipeline.ContentImporterContext) – Contains information for importing a game asset, such as a logger interface.

Returns:

Resulting game asset.

TextureProcessor

class TextureProcessor : Microsoft.Xna.Framework.Content.Pipeline.ContentProcessor<TextureContent, TextureContent>, IContentProcessor

Color ColorKeyColor

bool ColorKeyEnabled

bool GenerateMipmaps

bool PremultiplyAlpha

bool ResizeToPowerOfTwo

bool MakeSquare

TextureProcessorOutputFormat TextureFormat

public TextureContent Process(TextureContent input, ContentProcessorContext context)

Parameters:

• input (Microsoft.Xna.Framework.Content.Pipeline.Graphics.TextureContent) –
• context (Microsoft.Xna.Framework.Content.Pipeline.ContentProcessorContext) –

TextureProcessorOutputFormat

enum TextureProcessorOutputFormat : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

Specifies the target output (of type SurfaceFormat) of the texture processor. Used by TextureProcessor.TextureFormat.

TextureProcessorOutputFormat Color

The SurfaceFormat value, of the input TextureContent object, is converted to Color by the processor. Typically used for 2D graphics and overlays.

TextureProcessorOutputFormat DxtCompressed

The SurfaceFormat value, of the input TextureContent object, is converted to an appropriate DXT compression by the processor. If the input texture contains fractional alpha values, it is converted to DXT5 format (8 bits per texel); otherwise it is converted to DXT1 (4 bits per texel). This conversion reduces the resource’s size on the graphics card. Typically used for 3D textures such as 3D model textures.

TextureProcessorOutputFormat NoChange

The SurfaceFormat value, of the input TextureContent object, is not changed by the processor. Typically used for textures processed by an external tool.

TextureProcessorOutputFormat Compressed

The SurfaceFormat value, of the input TextureContent object, is converted to an appropriate compressed format for the target platform. This can include PVRTC for iOS, DXT for desktop, Windows 8 and Windows Phone 8, and ETC1 or BGRA4444 for Android.

TextureProcessorOutputFormat Color16Bit

The pixel depth of the input texture is reduced to BGR565 for opaque textures, otherwise it uses BGRA4444.

TextureProcessorOutputFormat Etc1Compressed

The input texture is compressed using ETC1 texture compression. Used on Android platforms.

TextureProcessorOutputFormat PvrCompressed

The input texture is compressed using PVR texture compression. Used on iOS and some Android platforms.

TextureProcessorOutputFormat AtcCompressed

The input texture is compressed using ATI texture compression. Used on some Android platforms.

TextureProfile

class TextureProfile : System.Object

public TextureProfile ForPlatform(TargetPlatform platform)

Find the profile for this target platform.

Parameters:

• platform (Microsoft.Xna.Framework.Content.Pipeline.TargetPlatform) – The platform target for textures.

Returns:

public abstract bool Supports(TargetPlatform platform)

Returns true if this profile supports texture processing for this platform.

Parameters:

• platform (Microsoft.Xna.Framework.Content.Pipeline.TargetPlatform) –

public abstract void Requirements(ContentProcessorContext context, TextureProcessorOutputFormat format, ref bool requiresPowerOfTwo, ref bool requiresSquare)

Parameters:

• context (Microsoft.Xna.Framework.Content.Pipeline.ContentProcessorContext) –
• format (Microsoft.Xna.Framework.Content.Pipeline.Processors.TextureProcessorOutputFormat) –
• (ref) requiresPowerOfTwo (bool) –
• (ref) requiresSquare (bool) –

public void ConvertTexture(ContentProcessorContext context, TextureContent content, TextureProcessorOutputFormat format, bool generateMipmaps, bool isSpriteFont)

Performs conversion of the texture content to the correct format.

Parameters:

• context (Microsoft.Xna.Framework.Content.Pipeline.ContentProcessorContext) – The processor context.
• content (Microsoft.Xna.Framework.Content.Pipeline.Graphics.TextureContent) – The content to be compressed.
• format (Microsoft.Xna.Framework.Content.Pipeline.Processors.TextureProcessorOutputFormat) – The user requested format for compression.
• generateMipmaps (bool) – If mipmap generation is required.
• isSpriteFont (bool) – If the texture has represents a sprite font, i.e. is greyscale and has sharp black/white contrast.

protected abstract void PlatformCompressTexture(ContentProcessorContext context, TextureContent content, TextureProcessorOutputFormat format, bool generateMipmaps, bool isSpriteFont)

Parameters:

• context (Microsoft.Xna.Framework.Content.Pipeline.ContentProcessorContext) –
• content (Microsoft.Xna.Framework.Content.Pipeline.Graphics.TextureContent) –
• format (Microsoft.Xna.Framework.Content.Pipeline.Processors.TextureProcessorOutputFormat) –
• generateMipmaps (bool) –
• isSpriteFont (bool) –

TextureReferenceDictionary

class TextureReferenceDictionary : Microsoft.Xna.Framework.Content.Pipeline.NamedValueDictionary<ExternalReference`1>, System.Collections.Generic.IDictionary<String, ExternalReference`1>, System.Collections.Generic.ICollection<KeyValuePair`2>, System.Collections.Generic.IEnumerable<KeyValuePair`2>, System.Collections.IEnumerable

Provides a collection of named references to texture files.

Token

class Token : System.Object

TokenType Type

string File

int Line

int Column

int StartPos

readonly int Length

int EndPos

string Text

System.Collections.Generic.List<Token> Skipped

System.Object Value

public void UpdateRange(Token token)

Parameters:

• token (TwoMGFX.Token) –

public string ToString()

TokenType

enum TokenType : System.Enum, System.IComparable, System.IFormattable, System.IConvertible

TokenType _NONE_

TokenType _UNDETERMINED_

TokenType Start

TokenType Technique_Declaration

TokenType FillMode_Solid

TokenType FillMode_WireFrame

TokenType FillModes

TokenType CullMode_None

TokenType CullMode_Cw

TokenType CullMode_Ccw

TokenType CullModes

TokenType Colors_None

TokenType Colors_Red

TokenType Colors_Green

TokenType Colors_Blue

TokenType Colors_Alpha

TokenType Colors_All

TokenType Colors_Boolean

TokenType Colors

TokenType ColorsMasks

TokenType Blend_Zero

TokenType Blend_One

TokenType Blend_SrcColor

TokenType Blend_InvSrcColor

TokenType Blend_SrcAlpha

TokenType Blend_InvSrcAlpha

TokenType Blend_DestAlpha

TokenType Blend_InvDestAlpha

TokenType Blend_DestColor

TokenType Blend_InvDestColor

TokenType Blend_SrcAlphaSat

TokenType Blend_BlendFactor

TokenType Blend_InvBlendFactor

TokenType Blends

TokenType BlendOp_Add

TokenType BlendOp_Subtract

TokenType BlendOp_RevSubtract

TokenType BlendOp_Min

TokenType BlendOp_Max

TokenType BlendOps

TokenType CmpFunc_Never

TokenType CmpFunc_Less

TokenType CmpFunc_Equal

TokenType CmpFunc_LessEqual

TokenType CmpFunc_Greater

TokenType CmpFunc_NotEqual

TokenType CmpFunc_GreaterEqual

TokenType CmpFunc_Always

TokenType CmpFunc

TokenType StencilOp_Keep

TokenType StencilOp_Zero

TokenType StencilOp_Replace

TokenType StencilOp_IncrSat

TokenType StencilOp_DecrSat

TokenType StencilOp_Invert

TokenType StencilOp_Incr

TokenType StencilOp_Decr

TokenType StencilOp

TokenType Render_State_CullMode

TokenType Render_State_FillMode

TokenType Render_State_AlphaBlendEnable

TokenType Render_State_SrcBlend

TokenType Render_State_DestBlend

TokenType Render_State_BlendOp

TokenType Render_State_ColorWriteEnable

TokenType Render_State_DepthBias

TokenType Render_State_SlopeScaleDepthBias

TokenType Render_State_ZEnable

TokenType Render_State_ZWriteEnable

TokenType Render_State_ZFunc

TokenType Render_State_MultiSampleAntiAlias

TokenType Render_State_ScissorTestEnable

TokenType Render_State_StencilEnable

TokenType Render_State_StencilFail

TokenType Render_State_StencilFunc

TokenType Render_State_StencilMask

TokenType Render_State_StencilPass

TokenType Render_State_StencilRef

TokenType Render_State_StencilWriteMask

TokenType Render_State_StencilZFail

TokenType Render_State_Expression

TokenType Pass_Declaration

TokenType VertexShader_Pass_Expression

TokenType PixelShader_Pass_Expression

TokenType AddressMode_Clamp

TokenType AddressMode_Wrap

TokenType AddressMode_Mirror

TokenType AddressMode_Border

TokenType AddressMode

TokenType TextureFilter_None

TokenType TextureFilter_Linear

TokenType TextureFilter_Point

TokenType TextureFilter_Anisotropic

TokenType TextureFilter

TokenType Sampler_State_Texture

TokenType Sampler_State_MinFilter

TokenType Sampler_State_MagFilter

TokenType Sampler_State_MipFilter

TokenType Sampler_State_Filter

TokenType Sampler_State_AddressU

TokenType Sampler_State_AddressV

TokenType Sampler_State_AddressW

TokenType Sampler_State_BorderColor

TokenType Sampler_State_MaxMipLevel

TokenType Sampler_State_MaxAnisotropy

TokenType Sampler_State_MipLodBias

TokenType Sampler_State_Expression

TokenType Sampler_Register_Expression

TokenType Sampler_Declaration_States

TokenType Sampler_Declaration

TokenType BlockComment

TokenType Comment

TokenType Whitespace

TokenType LinePragma

TokenType Pass

TokenType Technique

TokenType Sampler

TokenType SamplerState

TokenType VertexShader

TokenType PixelShader

TokenType Register

TokenType Boolean

TokenType Number

TokenType HexColor

TokenType Identifier

TokenType OpenBracket

TokenType CloseBracket

TokenType Equals

TokenType Colon

TokenType Comma

TokenType Semicolon

TokenType Or

TokenType OpenParenthesis

TokenType CloseParenthesis

TokenType OpenSquareBracket

TokenType CloseSquareBracket

TokenType LessThan

TokenType GreaterThan

TokenType Compile

TokenType ShaderModel

TokenType Code

TokenType EndOfFile

TokenType MinFilter

TokenType MagFilter

TokenType MipFilter

TokenType Filter

TokenType Texture

TokenType AddressU

TokenType AddressV

TokenType AddressW

TokenType BorderColor

TokenType MaxAnisotropy

TokenType MaxMipLevel

TokenType MipLodBias

TokenType Clamp

TokenType Wrap

TokenType Mirror

TokenType Border

TokenType None

TokenType Linear

TokenType Point

TokenType Anisotropic

TokenType AlphaBlendEnable

TokenType SrcBlend

TokenType DestBlend

TokenType BlendOp

TokenType ColorWriteEnable

TokenType ZEnable

TokenType ZWriteEnable

TokenType ZFunc

TokenType DepthBias

TokenType CullMode

TokenType FillMode

TokenType MultiSampleAntiAlias

TokenType ScissorTestEnable

TokenType SlopeScaleDepthBias

TokenType StencilEnable

TokenType StencilFail

TokenType StencilFunc

TokenType StencilMask

TokenType StencilPass

TokenType StencilRef

TokenType StencilWriteMask

TokenType StencilZFail

TokenType Never

TokenType Less

TokenType Equal

TokenType LessEqual

TokenType Greater

TokenType NotEqual

TokenType GreaterEqual

TokenType Always

TokenType Keep

TokenType Zero

TokenType Replace

TokenType IncrSat

TokenType DecrSat

TokenType Invert

TokenType Incr

TokenType Decr

TokenType Red

TokenType Green

TokenType Blue

TokenType Alpha

TokenType All

TokenType Cw

TokenType Ccw

TokenType Solid

TokenType WireFrame

TokenType Add

TokenType Subtract

TokenType RevSubtract

TokenType Min

TokenType Max

TokenType One

TokenType SrcColor

TokenType InvSrcColor

TokenType SrcAlpha

TokenType InvSrcAlpha

TokenType DestAlpha

TokenType InvDestAlpha

TokenType DestColor

TokenType InvDestColor

TokenType SrcAlphaSat

TokenType BlendFactor

TokenType InvBlendFactor

TypeExtensions

class TypeExtensions : System.Object

public Color ToColor(System.Drawing.Color color)

Parameters:

• color (System.Drawing.Color) –

public Vector3 ToVector3(System.Drawing.Color color)

Parameters:

• color (System.Drawing.Color) –

public void AddUnique<T>(System.Collections.Generic.List<T> list, MonoGame.Framework.Content.Pipeline.Builder.T item)

Type Parameters:  

• T –

Parameters:

• list (System.Collections.Generic.List<T>) –
• item (MonoGame.Framework.Content.Pipeline.Builder.T) –

public void AddRangeUnique<T>(System.Collections.Generic.List<T> dstList, System.Collections.Generic.List<T> list)

Type Parameters:  

• T –

Parameters:

• dstList (System.Collections.Generic.List<T>) –
• list (System.Collections.Generic.List<T>) –

VertexBufferContent

class VertexBufferContent : ContentItem

Provides methods and properties for managing a design-time vertex buffer that holds packed vertex data.

readonly System.Byte[] VertexData

Gets the array containing the raw bytes of the packed vertex data. Use this method to get and set the contents of the vertex buffer.

Value:Raw data of the packed vertex data.

VertexDeclarationContent VertexDeclaration

Gets and sets the associated VertexDeclarationContent object.

Value:The associated VertexDeclarationContent object.

public int SizeOf(System.Type type)

Gets the size of the specified type, in bytes.

Parameters:

• type (System.Type) – The type.

Returns:

The size of the specified type, in bytes.

public void Write<T>(int offset, int stride, System.Collections.Generic.IEnumerable<T> data)

Writes additional data into the vertex buffer. Writing begins at the specified byte offset, and each value is spaced according to the specified stride value (in bytes).

Type Parameters:  

• T – Type being written.

Parameters:

• offset (int) – Offset to begin writing at.
• stride (int) – Stride of the data being written, in bytes.
• data (System.Collections.Generic.IEnumerable<T>) – Enumerated collection of data.

public void Write(int offset, int stride, System.Type dataType, System.Collections.IEnumerable data)

Writes additional data into the vertex buffer. Writing begins at the specified byte offset, and each value is spaced according to the specified stride value (in bytes).

Parameters:

• offset (int) – Offset at which to begin writing.
• stride (int) – Stride of the data being written, in bytes.
• dataType (System.Type) – The type of data to be written.
• data (System.Collections.IEnumerable) – The data to write.

VertexChannel

class VertexChannel : System.Object, System.Collections.IList, System.Collections.ICollection, System.Collections.IEnumerable

Provides methods and properties for maintaining a vertex channel. A vertex channel is a list of arbitrary data with one value for each vertex. Channels are stored inside a GeometryContent and identified by name.

readonly int Count

Gets the number of elements in the vertex channel

readonly System.Type ElementType

Gets the type of data contained in this channel.

System.Object Item

readonly string Name

Gets the name of the vertex channel.

abstract System.Collections.IList get_Items()

void set_Name(string value)

Parameters:

• value (string) –

public bool Contains(System.Object value)

Determines whether the specified element is in the channel.

Parameters:

• value (System.Object) – Element being searched for.

Returns:

true if the element is present; false otherwise.

public void CopyTo(System.Array array, int index)

Copies the elements of the channel to an array, starting at the specified index.

Parameters:

• array (System.Array) – Array that will receive the copied channel elements.
• index (int) – Starting index for copy operation.

public System.Collections.IEnumerator GetEnumerator()

Gets an enumerator interface for reading channel content.

Returns:Enumeration of the channel content.

public int IndexOf(System.Object value)

Gets the index of the specified item.

Parameters:

• value (System.Object) – Item whose index is to be retrieved.

Returns:

Index of specified item.

public abstract System.Collections.Generic.IEnumerable<TargetType> ReadConvertedContent<TargetType>()

Reads channel content and automatically converts it to the specified vector format.

Type Parameters:  

• TargetType – Target vector format of the converted data.

Returns:

The converted data.

abstract void InsertRange(int index, System.Collections.IEnumerable data)

Inserts the range of values from the enumerable into the channel.

Parameters:

• index (int) – The zero-based index at which the new elements should be inserted.
• data (System.Collections.IEnumerable) – The data to insert into the channel.

VertexChannel<T>

class VertexChannel<T> : VertexChannel, System.Collections.IList, System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.Generic.IList<T>, System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>

Provides methods and properties for maintaining a vertex channel. This is a generic implementation of VertexChannel and, therefore, can handle strongly typed content data.

Type Parameters:  

• T –

readonly System.Type ElementType

Gets the type of data contained in this channel.

Microsoft.Xna.Framework.Content.Pipeline.Graphics.T Item

System.Collections.IList get_Items()

public bool Contains(Microsoft.Xna.Framework.Content.Pipeline.Graphics.T item)

Parameters:

• item (Microsoft.Xna.Framework.Content.Pipeline.Graphics.T) –

public void CopyTo(Microsoft.Xna.Framework.Content.Pipeline.Graphics.T[] array, int arrayIndex)

Parameters:

• array (Microsoft.Xna.Framework.Content.Pipeline.Graphics.T[]) –
• arrayIndex (int) –

public System.Collections.Generic.IEnumerator<T> GetEnumerator()

Gets an enumerator interface for reading channel content.

Returns:Enumeration of the channel content.

public int IndexOf(Microsoft.Xna.Framework.Content.Pipeline.Graphics.T item)

Parameters:

• item (Microsoft.Xna.Framework.Content.Pipeline.Graphics.T) –

void InsertRange(int index, System.Collections.IEnumerable data)

Inserts the range of values from the enumerable into the channel.

Parameters:

• index (int) – The zero-based index at which the new elements should be inserted.
• data (System.Collections.IEnumerable) – The data to insert into the channel.

public System.Collections.Generic.IEnumerable<TargetType> ReadConvertedContent<TargetType>()

Reads channel content and automatically converts it to the specified vector format.

Type Parameters:  

• TargetType – Target vector format for the converted channel data.

Returns:

The converted channel data.

VertexChannelCollection

class VertexChannelCollection : System.Object, System.Collections.Generic.IList<VertexChannel>, System.Collections.Generic.ICollection<VertexChannel>, System.Collections.Generic.IEnumerable<VertexChannel>, System.Collections.IEnumerable

Provides methods and properties for managing a list of vertex data channels.

readonly int Count

Gets the number of vertex channels in the collection.

VertexChannel Item

VertexChannel Item

public Microsoft.Xna.Framework.Content.Pipeline.Graphics.VertexChannel<ElementType> Add<ElementType>(string name, System.Collections.Generic.IEnumerable<ElementType> channelData)

Adds a new vertex channel to the end of the collection.

Type Parameters:  

• ElementType – Type of the channel.

Parameters:

• name (string) – Name of the new channel.
• channelData (System.Collections.Generic.IEnumerable<ElementType>) – Initial data for the new channel. If null, the channel is filled with the default value for that type.

Returns:

The newly added vertex channel.

public VertexChannel Add(string name, System.Type elementType, System.Collections.IEnumerable channelData)

Adds a new vertex channel to the end of the collection.

Parameters:

• name (string) – Name of the new channel.
• elementType (System.Type) – Type of data to be contained in the new channel.
• channelData (System.Collections.IEnumerable) – Initial data for the new channel. If null, the channel is filled with the default value for that type.

Returns:

The newly added vertex channel.

public void Clear()

Removes all vertex channels from the collection.

public bool Contains(string name)

Determines whether the collection contains the specified vertex channel.

Parameters:

• name (string) – Name of the channel being searched for.

Returns:

true if the channel was found; false otherwise.

public bool Contains(VertexChannel item)

Determines whether the collection contains the specified vertex channel.

Parameters:

• item (Microsoft.Xna.Framework.Content.Pipeline.Graphics.VertexChannel) – The channel being searched for.

Returns:

true if the channel was found; false otherwise.

public Microsoft.Xna.Framework.Content.Pipeline.Graphics.VertexChannel<TargetType> ConvertChannelContent<TargetType>(int index)

Converts the channel, at the specified index, to another vector format.

Type Parameters:  

• TargetType – Type of the target format. Can be one of the following: Single, Vector2, Vector3, Vector4, IPackedVector

Parameters:

• index (int) – Index of the channel to be converted.

Returns:

New channel in the specified format.

public Microsoft.Xna.Framework.Content.Pipeline.Graphics.VertexChannel<TargetType> ConvertChannelContent<TargetType>(string name)

Converts the channel, specified by name to another vector format.

Type Parameters:  

• TargetType – Type of the target format. Can be one of the following: Single, Vector2, Vector3, Vector4, IPackedVector

Parameters:

• name (string) – Name of the channel to be converted.

Returns:

New channel in the specified format.

public VertexChannel<T> Get<T>(int index)

Gets the vertex channel with the specified index and content type.

Type Parameters:  

• T – Type of a vertex channel.

Parameters:

• index (int) – Index of a vertex channel.

Returns:

The vertex channel.

public VertexChannel<T> Get<T>(string name)

Gets the vertex channel with the specified name and content type.

Type Parameters:  

• T – Type of the vertex channel.

Parameters:

• name (string) – Name of a vertex channel.

Returns:

The vertex channel.

public System.Collections.Generic.IEnumerator<VertexChannel> GetEnumerator()

Gets an enumerator that iterates through the vertex channels of a collection.

Returns:Enumerator for the collection.

public int IndexOf(string name)

Determines the index of a vertex channel with the specified name.

Parameters:

• name (string) – Name of the vertex channel being searched for.

Returns:

Index of the vertex channel.

public int IndexOf(VertexChannel item)

Determines the index of the specified vertex channel.

Parameters:

• item (Microsoft.Xna.Framework.Content.Pipeline.Graphics.VertexChannel) – Vertex channel being searched for.

Returns:

Index of the vertex channel.

public Microsoft.Xna.Framework.Content.Pipeline.Graphics.VertexChannel<ElementType> Insert<ElementType>(int index, string name, System.Collections.Generic.IEnumerable<ElementType> channelData)

Inserts a new vertex channel at the specified position.

Type Parameters:  

• ElementType – Type of the new channel.

Parameters:

• index (int) – Index for channel insertion.
• name (string) – Name of the new channel.
• channelData (System.Collections.Generic.IEnumerable<ElementType>) – The new channel.

Returns:

The inserted vertex channel.

public VertexChannel Insert(int index, string name, System.Type elementType, System.Collections.IEnumerable channelData)

Inserts a new vertex channel at the specified position.

Parameters:

• index (int) – Index for channel insertion.
• name (string) – Name of the new channel.
• elementType (System.Type) – Type of the new channel.
• channelData (System.Collections.IEnumerable) – Initial data for the new channel. If null, it is filled with the default value.

Returns:

The inserted vertex channel.

public bool Remove(string name)

Removes the specified vertex channel from the collection.

Parameters:

• name (string) – Name of the vertex channel being removed.

Returns:

true if the channel was removed; false otherwise.

public bool Remove(VertexChannel item)

Removes the specified vertex channel from the collection.

Parameters:

• item (Microsoft.Xna.Framework.Content.Pipeline.Graphics.VertexChannel) – The vertex channel being removed.

Returns:

true if the channel was removed; false otherwise.

public void RemoveAt(int index)

Removes the vertex channel at the specified index position.

Parameters:

• index (int) – Index of the vertex channel being removed.

VertexChannelNames

class VertexChannelNames : System.Object

Provides properties for managing a collection of vertex channel names.

public string Binormal(int usageIndex)

Gets the name of a binormal vector channel with the specified index. This will typically contain Vector3 data.

Parameters:

• usageIndex (int) – Zero-based index of the vector channel being retrieved.

Returns:

Name of the retrieved vector channel.

public string Color(int usageIndex)

Gets the name of a color channel with the specified index. This will typically contain Vector3 data.

Parameters:

• usageIndex (int) – Zero-based index of the color channel being retrieved.

Returns:

Name of the retrieved color channel.

public string DecodeBaseName(string encodedName)

Gets a channel base name stub from the encoded string format.

Parameters:

• encodedName (string) – Encoded string to be decoded.

Returns:

Extracted base name.

public int DecodeUsageIndex(string encodedName)

Gets a channel usage index from the encoded format.

Parameters:

• encodedName (string) – Encoded name to be decoded.

Returns:

Resulting channel usage index.

public string EncodeName(string baseName, int usageIndex)

Combines a channel name stub and usage index into a string name.

Parameters:

• baseName (string) – A channel base name stub.
• usageIndex (int) – A channel usage index.

Returns:

Resulting encoded name.

public string EncodeName(VertexElementUsage vertexElementUsage, int usageIndex)

Combines a vertex declaration usage and usage index into a string name.

Parameters:

• vertexElementUsage (Microsoft.Xna.Framework.Graphics.VertexElementUsage) – A vertex declaration.
• usageIndex (int) – An index for the vertex declaration.

Returns:

Resulting encoded name.

public string Normal()

Gets the name of the primary normal channel. This will typically contain Vector3 data.

Returns:Primary normal channel name.

public string Normal(int usageIndex)

Gets the name of a normal channel with the specified index. This will typically contain Vector3 data.

Parameters:

• usageIndex (int) – Zero-based index of the normal channel being retrieved.

Returns:

Normal channel at the specified index.

public string Tangent(int usageIndex)

Gets the name of a tangent vector channel with the specified index. This will typically contain Vector3 data.

Parameters:

• usageIndex (int) – Zero-based index of the tangent vector channel being retrieved.

Returns:

Name of the retrieved tangent vector channel.

public string TextureCoordinate(int usageIndex)

Gets the name of a texture coordinate channel with the specified index. This will typically contain Vector3 data.

Parameters:

• usageIndex (int) – Zero-based index of the texture coordinate channel being retrieved.

Returns:

Name of the retrieved texture coordinate channel.

public bool TryDecodeUsage(string encodedName, ref VertexElementUsage usage)

Parameters:

• encodedName (string) –
• (ref) usage (Microsoft.Xna.Framework.Graphics.VertexElementUsage) –

public string Weights()

Gets the name of the primary animation weights channel. This will typically contain data on the bone weights for a vertex channel. For more information, see BoneWeightCollection.

Returns:Name of the primary animation weights channel.

public string Weights(int usageIndex)

Gets the name of an animation weights channel at the specified index. This will typically contain data on the bone weights for a vertex channel. For more information, see BoneWeightCollection.

Parameters:

• usageIndex (int) – Index of the animation weight channel to be retrieved.

Returns:

Name of the retrieved animation weights channel.

VertexContent

class VertexContent : System.Object

Provides methods and properties for maintaining the vertex data of a GeometryContent.

readonly VertexChannelCollection Channels

Gets the list of named vertex data channels in the VertexContent.

Value:Collection of vertex data channels.

readonly Microsoft.Xna.Framework.Content.Pipeline.Graphics.VertexChannel<Int32> PositionIndices

Gets the list of position indices.

Value:Position of the position index being retrieved.

readonly IndirectPositionCollection Positions

Gets position data from the parent mesh object.

Value:Collection of vertex positions for the mesh.

readonly int VertexCount

Number of vertices for the content.

Value:Number of vertices.

public int Add(int positionIndex)

Appends a new vertex index to the end of the PositionIndices collection. Other vertex channels will automatically be extended and the new indices populated with default values.

Parameters:

• positionIndex (int) – Index into the MeshContent.Positions member of the parent.

Returns:

Index of the new entry. This can be added to the Indices member of the parent.

public void AddRange(System.Collections.Generic.IEnumerable<Int32> positionIndexCollection)

Appends multiple vertex indices to the end of the PositionIndices collection. Other vertex channels will automatically be extended and the new indices populated with default values.

Parameters:

• positionIndexCollection (System.Collections.Generic.IEnumerable<Int32>) – Index into the Positions member of the parent.

public VertexBufferContent CreateVertexBuffer()

Converts design-time vertex position and channel data into a vertex buffer format that a graphics device can recognize.

Returns:A packed vertex buffer.

public void Insert(int index, int positionIndex)

Inserts a new vertex index to the PositionIndices collection. Other vertex channels will automatically be extended and the new indices populated with default values.

Parameters:

• index (int) – Vertex index to be inserted.
• positionIndex (int) – Position of new vertex index in the collection.

public void InsertRange(int index, System.Collections.Generic.IEnumerable<Int32> positionIndexCollection)

Inserts multiple vertex indices to the PositionIndices collection. Other vertex channels will automatically be extended and the new indices populated with default values.

Parameters:

• index (int) – Vertex index to be inserted.
• positionIndexCollection (System.Collections.Generic.IEnumerable<Int32>) – Position of the first element of the inserted range in the collection.

public void RemoveAt(int index)

Removes a vertex index from the specified location in both PositionIndices and VertexChannel<T>.

Parameters:

• index (int) – Index of the vertex to be removed.

public void RemoveRange(int index, int count)

Removes a range of vertex indices from the specified location in both PositionIndices and VertexChannel<T>.

Parameters:

• index (int) – Index of the first vertex index to be removed.
• count (int) – Number of indices to remove.

VertexDeclarationContent

class VertexDeclarationContent : ContentItem

Provides methods and properties for maintaining the vertex declaration data of a VertexContent.

readonly System.Collections.ObjectModel.Collection<VertexElement> VertexElements

Gets the VertexElement object of the vertex declaration.

Value:The VertexElement object of the vertex declaration.

System.Nullable<Int32> VertexStride

The number of bytes from one vertex to the next.

Value:The stride (in bytes).

VideoContent

class VideoContent : ContentItem, System.IDisposable

Provides a base class for all video objects.

readonly int BitsPerSecond

Gets the bit rate for this video.

readonly System.TimeSpan Duration

Gets the duration of this video.

string Filename

Gets or sets the file name for this video.

readonly float FramesPerSecond

Gets the frame rate for this video.

readonly int Height

Gets the height of this video.

VideoSoundtrackType VideoSoundtrackType

Gets or sets the type of soundtrack accompanying the video.

readonly int Width

Gets the width of this video.

public void Dispose()

Immediately releases the unmanaged resources used by this object.

VideoProcessor

class VideoProcessor : Microsoft.Xna.Framework.Content.Pipeline.ContentProcessor<VideoContent, VideoContent>, IContentProcessor

public VideoContent Process(VideoContent input, ContentProcessorContext context)

Parameters:

• input (Microsoft.Xna.Framework.Content.Pipeline.VideoContent) –
• context (Microsoft.Xna.Framework.Content.Pipeline.ContentProcessorContext) –

WavImporter

class WavImporter : Microsoft.Xna.Framework.Content.Pipeline.ContentImporter<AudioContent>, IContentImporter

Provides methods for reading .wav audio files for use in the Content Pipeline.

public AudioContent Import(string filename, ContentImporterContext context)

Called by the XNA Framework when importing a .wav audio file to be used as a game asset. This is the method called by the XNA Framework when an asset is to be imported into an object that can be recognized by the Content Pipeline.

Parameters:

• filename (string) – Name of a game asset file.
• context (Microsoft.Xna.Framework.Content.Pipeline.ContentImporterContext) – Contains information for importing a game asset, such as a logger interface.

Returns:

Resulting game asset.

WmaImporter

class WmaImporter : Microsoft.Xna.Framework.Content.Pipeline.ContentImporter<AudioContent>, IContentImporter

Provides methods for reading Windows Media Audio (.wma) files for use in the Content Pipeline.

public AudioContent Import(string filename, ContentImporterContext context)

Called by the XNA Framework when importing a .wma file to be used as a game asset. This is the method called by the XNA Framework when an asset is to be imported into an object that can be recognized by the Content Pipeline.

Parameters:

• filename (string) – Name of a game asset file.
• context (Microsoft.Xna.Framework.Content.Pipeline.ContentImporterContext) – Contains information for importing a game asset, such as a logger interface.

Returns:

Resulting game asset.

WmvImporter

class WmvImporter : Microsoft.Xna.Framework.Content.Pipeline.ContentImporter<VideoContent>, IContentImporter

Provides methods for reading Windows Media Video (.wmv) files for use in the Content Pipeline.

public VideoContent Import(string filename, ContentImporterContext context)

Called by the XNA Framework when importing a .wmv file to be used as a game asset. This is the method called by the XNA Framework when an asset is to be imported into an object that can be recognized by the Content Pipeline.

Parameters:

• filename (string) – Name of a game asset file.
• context (Microsoft.Xna.Framework.Content.Pipeline.ContentImporterContext) – Contains information for importing a game asset, such as a logger interface.

Returns:

Resulting game asset.

XImporter

class XImporter : Microsoft.Xna.Framework.Content.Pipeline.ContentImporter<NodeContent>, IContentImporter

Provides methods for reading DirectX Object (.x) files for use in the Content Pipeline.

public NodeContent Import(string filename, ContentImporterContext context)

Called by the XNA Framework when importing a .x file to be used as a game asset. This is the method called by the XNA Framework when an asset is to be imported into an object that can be recognized by the Content Pipeline.

Parameters:

• filename (string) – Name of a game asset file.
• context (Microsoft.Xna.Framework.Content.Pipeline.ContentImporterContext) – Contains information for importing a game asset, such as a logger interface.

Returns:

Resulting game asset.

XmlColor

class XmlColor : System.Object

Helper for serializing color types with the XmlSerializer.

string Default

public System.Drawing.Color op_Implicit(XmlColor x)

Parameters:

• x (MonoGame.Framework.Content.Pipeline.Builder.XmlColor) –

public XmlColor op_Implicit(System.Drawing.Color c)

Parameters:

• c (System.Drawing.Color) –

public string FromColor(System.Drawing.Color color)

Parameters:

• color (System.Drawing.Color) –

public System.Drawing.Color ToColor(string value)

Parameters:

• value (string) –

XmlImporter

class XmlImporter : Microsoft.Xna.Framework.Content.Pipeline.ContentImporter<Object>, IContentImporter

Implements an importer for reading intermediate XML files. This is a wrapper around IntermediateSerializer.

public System.Object Import(string filename, ContentImporterContext context)

Called by the XNA Framework when importing an intermediate file to be used as a game asset. This is the method called by the XNA Framework when an asset is to be imported into an object that can be recognized by the Content Pipeline.

Parameters:

• filename (string) – Name of a game asset file.
• context (Microsoft.Xna.Framework.Content.Pipeline.ContentImporterContext) – Contains information for importing a game asset, such as a logger interface.

Returns:

The imported game asset.

Other Documentation

Miscellanous documentation that doesn’t belong under any other category.

Internal Implementations

Warning

This documentation covers the internal implementations of services offered by Protogame. While those implementations are always public in the Protogame API (to give you the most flexibility), the documentation of those classes is not always kept up to date.

You should always refer to the service (interface) documentation if it is available.

This documentation covers implementation-specific details of how various services in Protogame are implemented.

DefaultAudioHandle

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the IAudioHandle service via dependency injection to access this functionality.

Information documented here may not be up to date.

class DefaultAudioHandle : System.Object, IAudioHandle

The default implementation of T:Protogame.IAudioHandle.

float Volume

readonly bool IsPlaying

public void Loop()

public void Pause()

public void Play()

public void Stop(bool immediate)

Parameters:

• immediate (bool) –

DefaultAudioUtilities

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the IAudioUtilities service via dependency injection to access this functionality.

Information documented here may not be up to date.

class DefaultAudioUtilities : System.Object, IAudioUtilities

The default implementation of T:Protogame.IAudioUtilities.

public IAudioHandle GetHandle(Protogame.IAssetReference<AudioAsset> asset)

Parameters:

• asset (Protogame.IAssetReference<AudioAsset>) –

public IAudioHandle Loop(Protogame.IAssetReference<AudioAsset> asset)

Parameters:

• asset (Protogame.IAssetReference<AudioAsset>) –

public IAudioHandle Play(Protogame.IAssetReference<AudioAsset> asset)

Parameters:

• asset (Protogame.IAssetReference<AudioAsset>) –

FirstPersonCamera

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the IFirstPersonCamera service via dependency injection to access this functionality.

Information documented here may not be up to date.

class FirstPersonCamera : System.Object, IFirstPersonCamera

The default implementation for T:Protogame.IFirstPersonCamera.

public void Apply(IRenderContext renderContext, Vector3 position, Vector3 lookAt, System.Nullable<Vector3> up, float fieldOfView, float nearPlaneDistance, float farPlaneDistance)

Parameters:

• renderContext (Protogame.IRenderContext) –
• position (Microsoft.Xna.Framework.Vector3) –
• lookAt (Microsoft.Xna.Framework.Vector3) –
• up (System.Nullable<Vector3>) –
• fieldOfView (float) –
• nearPlaneDistance (float) –
• farPlaneDistance (float) –

DefaultCollision

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the ICollision service via dependency injection to access this functionality.

Information documented here may not be up to date.

class DefaultCollision : System.Object, ICollision

The default implementation of T:Protogame.ICollision.

public System.Nullable<Vector3> CollidesWithTriangle(Ray ray, Microsoft.Xna.Framework.Vector3[] trianglePoints, ref float distance, bool testCulling)

Parameters:

• ray (Microsoft.Xna.Framework.Ray) –
• trianglePoints (Microsoft.Xna.Framework.Vector3[]) –
• (ref) distance (float) –
• testCulling (bool) –

public System.Nullable<Vector3> CollidesWithTriangle(Ray ray, Vector3 vert0, Vector3 vert1, Vector3 vert2, ref float distance, bool testCulling)

Parameters:

• ray (Microsoft.Xna.Framework.Ray) –
• vert0 (Microsoft.Xna.Framework.Vector3) –
• vert1 (Microsoft.Xna.Framework.Vector3) –
• vert2 (Microsoft.Xna.Framework.Vector3) –
• (ref) distance (float) –
• testCulling (bool) –

CoreGame<TInitialWorld, TWorldManager>

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the Protogame.CoreGame{TInitialWorld} service via dependency injection to access this functionality.

Information documented here may not be up to date.

class CoreGame<TInitialWorld, TWorldManager> : Game, System.IDisposable, Protogame.ICoreGame

The implementation of Protogame’s base game class. In previous versions of Protogame, this acted as the base class for the developer’s Game class. However newer games written in Protogame should use T:Protogame.CoreGame`1 instead, as this correctly sets games to use the new render pipeline, which sets TWorldManager to be T:Protogame.RenderPipelineWorldManager automatically.

Type Parameters:  

• TInitialWorld – The initial world class to start the game with.
• TWorldManager – The world manager class for this game.

readonly IGameContext GameContext

Gets the current game context. You should not generally access this property; outside an explicit Update or Render loop, the state of the game context is not guaranteed. Inside the context of an Update or Render loop, the game context is already provided.

Value:The current game context.

readonly IUpdateContext UpdateContext

Gets the current update context. You should not generally access this property; outside an explicit Update loop, the state of the update context is not guaranteed. Inside the context of an Update loop, the update context is already provided.

Value:The current update context.

readonly IRenderContext RenderContext

Gets the current render context. You should not generally access this property; outside an explicit Render loop, the state of the render context is not guaranteed. Inside the context of an Render loop, the render context is already provided.

Value:The current update context.

readonly Protogame.IGameWindow Window

A platform independent representation of a game window.

Value:The game window.

readonly GraphicsDeviceManager GraphicsDeviceManager

The graphics device manager used by the game.

Value:The graphics device manager.

int SkipFrames

The number of frames to skip before updating or rendering.

DefaultBoundingBoxUtilities

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the Protogame.IBoundingBoxUtilities service via dependency injection to access this functionality.

Information documented here may not be up to date.

class DefaultBoundingBoxUtilities : System.Object, Protogame.IBoundingBoxUtilities

The default implementation of T:Protogame.IBoundingBoxUtilities.

public bool Overlaps(Protogame.IBoundingBox[] boundingBoxes)

Parameters:

• boundingBoxes (Protogame.IBoundingBox[]) –

DefaultFinalTransform

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the Protogame.IFinalTransform service via dependency injection to access this functionality.

Information documented here may not be up to date.

class DefaultFinalTransform : System.Object, Protogame.IFinalTransform

The default implementation of T:Protogame.IFinalTransform.

readonly Matrix AbsoluteMatrix

readonly Matrix AbsoluteMatrixWithoutScale

readonly Vector3 AbsolutePosition

readonly Quaternion AbsoluteRotation

readonly Protogame.IFinalTransform Parent

readonly IHasTransform ParentObject

readonly Protogame.ITransform Child

readonly IHasTransform ChildObject

public Protogame.IFinalTransform Create(IHasTransform parent, IHasTransform child)

Parameters:

• parent (Protogame.IHasTransform) –
• child (Protogame.IHasTransform) –

public Protogame.IFinalTransform Create(IHasTransform detachedChild)

Parameters:

• detachedChild (Protogame.IHasTransform) –

public string ToString()

DefaultKeyboardStringReader

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the Protogame.IKeyboardStringReader service via dependency injection to access this functionality.

Information documented here may not be up to date.

class DefaultKeyboardStringReader : System.Object, Protogame.IKeyboardStringReader

The default implementation of T:Protogame.IKeyboardStringReader.

int FirstRepeatKeyInterval

The amount of time in milliseconds a key needs to be held down to repeat for the first time.

Value:The first repeat key interval.

int RepeatKeyInterval

The amount of time in milliseconds a key needs to be held down to repeat for the second time and beyond.

Value:The repeat key interval.

public void Process(KeyboardState keyboard, GameTime time, System.Text.StringBuilder text)

Process the current keyboard state and add or remove characters from the given StringBuilder.

Parameters:

• keyboard (Microsoft.Xna.Framework.Input.KeyboardState) – The keyboard state input is being read from.
• time (Microsoft.Xna.Framework.GameTime) – Current GameTime.
• text (System.Text.StringBuilder) – The StringBuilder to be modified based on keyboard state.

DefaultRawLaunchArguments

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the Protogame.IRawLaunchArguments service via dependency injection to access this functionality.

Information documented here may not be up to date.

class DefaultRawLaunchArguments : System.Object, Protogame.IRawLaunchArguments

The default implementation of T:Protogame.IRawLaunchArguments.

readonly System.String[] Arguments

DefaultStringSanitizer

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the IStringSanitizer service via dependency injection to access this functionality.

Information documented here may not be up to date.

class DefaultStringSanitizer : System.Object, IStringSanitizer

The default implementation of T:Protogame.IStringSanitizer.

public string SanitizeCharacters(SpriteFont font, string text)

Parameters:

• font (Microsoft.Xna.Framework.Graphics.SpriteFont) –
• text (string) –

DefaultTileUtilities

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the Protogame.ITileUtilities service via dependency injection to access this functionality.

Information documented here may not be up to date.

class DefaultTileUtilities : System.Object, Protogame.ITileUtilities

The default implementation of T:Protogame.ITileUtilities.

public void InitializeTile(Protogame.ITileEntity entity, string tilesetAssetName)

Parameters:

• entity (Protogame.ITileEntity) –
• tilesetAssetName (string) –

public void RenderTile(Protogame.ITileEntity entity, IRenderContext renderContext)

Parameters:

• entity (Protogame.ITileEntity) –
• renderContext (Protogame.IRenderContext) –

DefaultTransform

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the Protogame.ITransform service via dependency injection to access this functionality.

Information documented here may not be up to date.

class DefaultTransform : System.Object, Protogame.ITransform

The default implementation of T:Protogame.ITransform.

Vector3 LocalPosition

Quaternion LocalRotation

Vector3 LocalScale

readonly Matrix LocalMatrix

readonly Matrix LocalMatrixWithoutScale

readonly bool IsSRTMatrix

public void add_Modified(System.EventHandler value)

Parameters:

• value (System.EventHandler) –

public void remove_Modified(System.EventHandler value)

Parameters:

• value (System.EventHandler) –

public void Assign(Protogame.ITransform from)

Parameters:

• from (Protogame.ITransform) –

public void ResetAsSRTMatrix()

public void SetFromSRTMatrix(Vector3 localPosition, Quaternion localRotation, Vector3 localScale)

Parameters:

• localPosition (Microsoft.Xna.Framework.Vector3) –
• localRotation (Microsoft.Xna.Framework.Quaternion) –
• localScale (Microsoft.Xna.Framework.Vector3) –

public Protogame.NetworkTransform SerializeToNetwork()

public void ResetAsCustomMatrix()

public void SetFromCustomMatrix(Matrix localMatrix)

Parameters:

• localMatrix (Microsoft.Xna.Framework.Matrix) –

public string ToString()

DefaultTransformUtilities

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the Protogame.ITransformUtilities service via dependency injection to access this functionality.

Information documented here may not be up to date.

class DefaultTransformUtilities : System.Object, Protogame.ITransformUtilities

The default implementation of T:Protogame.ITransformUtilities.

public Protogame.ITransform CreateFromSRTMatrix(Vector3 localScale, Quaternion localRotation, Vector3 localPosition)

Parameters:

• localScale (Microsoft.Xna.Framework.Vector3) –
• localRotation (Microsoft.Xna.Framework.Quaternion) –
• localPosition (Microsoft.Xna.Framework.Vector3) –

public Protogame.ITransform CreateFromModifiedSRTTransform(Protogame.ITransform existingTransform, Vector3 scaleFactor, Quaternion appliedRotation, Vector3 addedPosition)

Parameters:

• existingTransform (Protogame.ITransform) –
• scaleFactor (Microsoft.Xna.Framework.Vector3) –
• appliedRotation (Microsoft.Xna.Framework.Quaternion) –
• addedPosition (Microsoft.Xna.Framework.Vector3) –

public Protogame.ITransform CreateFromModifiedSRTFinalTransform(Protogame.IFinalTransform existingFinalTransform, Vector3 scaleFactor, Quaternion appliedRotation, Vector3 addedPosition)

Parameters:

• existingFinalTransform (Protogame.IFinalTransform) –
• scaleFactor (Microsoft.Xna.Framework.Vector3) –
• appliedRotation (Microsoft.Xna.Framework.Quaternion) –
• addedPosition (Microsoft.Xna.Framework.Vector3) –

public Protogame.ITransform CreateFromCustomMatrix(Matrix localMatrix)

Parameters:

• localMatrix (Microsoft.Xna.Framework.Matrix) –

public Protogame.ITransform CreateFromDependencyInjection(IContext dependencyInjectionContext)

Parameters:

• dependencyInjectionContext (Protoinject.IContext) –

public Protogame.ITransform CreateLocalPosition(float x, float y, float z)

Parameters:

• x (float) –
• y (float) –
• z (float) –

public Protogame.ITransform CreateLocalPosition(Vector3 localPosition)

Parameters:

• localPosition (Microsoft.Xna.Framework.Vector3) –

ProtogameBaseModule

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the ProtogameCoreModule service via dependency injection to access this functionality.

Information documented here may not be up to date.

class ProtogameBaseModule : System.Object, IProtoinjectModule

The base Protogame dependency injection module which is used by both T:Protogame.ProtogameCoreModule and T:Protogame.ProtogameServerModule to bind common services.

public void Load(IKernel kernel)

Do not directly call this method, use T:Protogame.ProtogameCoreModule or T:Protogame.ProtogameServerModule.

Parameters:

• kernel (Protoinject.IKernel) –

NullDebugRenderer

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the IDebugRenderer service via dependency injection to access this functionality.

Information documented here may not be up to date.

class NullDebugRenderer : System.Object, IDebugRenderer

An implementation of the debug rendering which is used in headless servers.

public void RenderDebugLine(IRenderContext renderContext, Vector3 point1, Vector3 point2, Color color1, Color color2)

Parameters:

• renderContext (Protogame.IRenderContext) –
• point1 (Microsoft.Xna.Framework.Vector3) –
• point2 (Microsoft.Xna.Framework.Vector3) –
• color1 (Microsoft.Xna.Framework.Color) –
• color2 (Microsoft.Xna.Framework.Color) –

public void RenderDebugTriangle(IRenderContext renderContext, Vector3 point1, Vector3 point2, Vector3 point3, Color color1, Color color2, Color color3)

Parameters:

• renderContext (Protogame.IRenderContext) –
• point1 (Microsoft.Xna.Framework.Vector3) –
• point2 (Microsoft.Xna.Framework.Vector3) –
• point3 (Microsoft.Xna.Framework.Vector3) –
• color1 (Microsoft.Xna.Framework.Color) –
• color2 (Microsoft.Xna.Framework.Color) –
• color3 (Microsoft.Xna.Framework.Color) –

ConsoleEventBinder

Warning

This documentation is for an internal class. This class is not intended to be used by developers, and is used internally within the engine to provide functionality.

Information documented here may not be up to date.

class ConsoleEventBinder : Protogame.StaticEventBinder<IGameContext>, Protogame.IEventBinder<IGameContext>

Binds events such that the in-game console will receive input.

You shouldn’t need to set up this event binder manually, as it is handled when the T:Protogame.ProtogameEventsIoCModule is loaded.

public void Configure()

Configures the event system so that events are propagated to the console event listener.

ConsoleEventListener

Warning

This documentation is for an internal class. This class is not intended to be used by developers, and is used internally within the engine to provide functionality.

Information documented here may not be up to date.

class ConsoleEventListener : System.Object, Protogame.IEventListener<IGameContext>

Handles incoming events and passes them to the in-game console when appropriate.

public bool Handle(IGameContext gameContext, Protogame.IEventEngine<IGameContext> eventEngine, Event event)

Handles the event as appropriate for the in-game console.

Parameters:

• gameContext (Protogame.IGameContext) – The current game context.
• eventEngine (Protogame.IEventEngine<IGameContext>) – The current event engine.
• event (Protogame.Event) – The event that is being handled.

Returns:

The T:System.Boolean.

DefaultEventEngine<TContext>

Warning

This documentation is for an internal class. This class is not intended to be used by developers, and is used internally within the engine to provide functionality.

Information documented here may not be up to date.

class DefaultEventEngine<TContext> : System.Object, Protogame.IEventEngine<TContext>

The default implementation for an T:Protogame.IEventEngine`1.

Type Parameters:  

• TContext – The context that is being passed to events.

public void Fire(Protogame.TContext context, Event event)

Parameters:

• context (Protogame.TContext) –
• event (Protogame.Event) –

EventEngineHook

Warning

This documentation is for an internal class. This class is not intended to be used by developers, and is used internally within the engine to provide functionality.

Information documented here may not be up to date.

class EventEngineHook : System.Object, IEngineHook

A game engine hook that raised appropriate input events as they occur.

public void Render(IGameContext gameContext, IRenderContext renderContext)

The render callback for the engine hook. This is triggered right before the rendering of the world manager.

Parameters:

• gameContext (Protogame.IGameContext) – The game context.
• renderContext (Protogame.IRenderContext) – The render context.

public void Update(IGameContext gameContext, IUpdateContext updateContext)

The update callback for the engine hook. This is triggered right before the update of the world manager.

For this engine hook, this updates and fires input events as appropriate.

Parameters:

• gameContext (Protogame.IGameContext) – The game context.
• updateContext (Protogame.IUpdateContext) – The update context.

public void Update(Protogame.IServerContext serverContext, IUpdateContext updateContext)

Parameters:

• serverContext (Protogame.IServerContext) –
• updateContext (Protogame.IUpdateContext) –

Default2DBatchedLoadingScreenRenderPass

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the I2DBatchedRenderPass service via dependency injection to access this functionality.

Information documented here may not be up to date.

class Default2DBatchedLoadingScreenRenderPass : System.Object, I2DBatchedLoadingScreenRenderPass, IRenderPass, Protogame.IRenderPassWithViewport

The default implementation of an T:Protogame.I2DBatchedLoadingScreenRenderPass.

readonly bool IsPostProcessingPass

readonly bool SkipWorldRenderBelow

readonly bool SkipWorldRenderAbove

readonly bool SkipEntityRender

readonly bool SkipEngineHookRender

readonly string EffectTechniqueName

System.Nullable<Viewport> Viewport

SpriteSortMode TextureSortMode

string Name

public void BeginRenderPass(IGameContext gameContext, IRenderContext renderContext, IRenderPass previousPass, RenderTarget2D postProcessingSource)

Parameters:

• gameContext (Protogame.IGameContext) –
• renderContext (Protogame.IRenderContext) –
• previousPass (Protogame.IRenderPass) –
• postProcessingSource (Microsoft.Xna.Framework.Graphics.RenderTarget2D) –

public void EndRenderPass(IGameContext gameContext, IRenderContext renderContext, IRenderPass nextPass)

Parameters:

• gameContext (Protogame.IGameContext) –
• renderContext (Protogame.IRenderContext) –
• nextPass (Protogame.IRenderPass) –

Default2DBatchedRenderPass

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the I2DBatchedRenderPass service via dependency injection to access this functionality.

Information documented here may not be up to date.

class Default2DBatchedRenderPass : System.Object, I2DBatchedRenderPass, IRenderPass, Protogame.IRenderPassWithViewport

The default implementation of an T:Protogame.I2DBatchedRenderPass.

readonly bool IsPostProcessingPass

readonly bool SkipWorldRenderBelow

readonly bool SkipWorldRenderAbove

readonly bool SkipEntityRender

readonly bool SkipEngineHookRender

readonly string EffectTechniqueName

System.Nullable<Viewport> Viewport

SpriteSortMode TextureSortMode

string Name

public void BeginRenderPass(IGameContext gameContext, IRenderContext renderContext, IRenderPass previousPass, RenderTarget2D postProcessingSource)

Parameters:

• gameContext (Protogame.IGameContext) –
• renderContext (Protogame.IRenderContext) –
• previousPass (Protogame.IRenderPass) –
• postProcessingSource (Microsoft.Xna.Framework.Graphics.RenderTarget2D) –

public void EndRenderPass(IGameContext gameContext, IRenderContext renderContext, IRenderPass nextPass)

Parameters:

• gameContext (Protogame.IGameContext) –
• renderContext (Protogame.IRenderContext) –
• nextPass (Protogame.IRenderPass) –

Default2DDirectRenderPass

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the I2DDirectRenderPass service via dependency injection to access this functionality.

Information documented here may not be up to date.

class Default2DDirectRenderPass : System.Object, I2DDirectRenderPass, IRenderPass, Protogame.IRenderPassWithViewport

The default implementation of an T:Protogame.I2DDirectRenderPass.

readonly bool IsPostProcessingPass

readonly bool SkipWorldRenderBelow

readonly bool SkipWorldRenderAbove

readonly bool SkipEntityRender

readonly bool SkipEngineHookRender

readonly string EffectTechniqueName

System.Nullable<Viewport> Viewport

string Name

public void BeginRenderPass(IGameContext gameContext, IRenderContext renderContext, IRenderPass previousPass, RenderTarget2D postProcessingSource)

Parameters:

• gameContext (Protogame.IGameContext) –
• renderContext (Protogame.IRenderContext) –
• previousPass (Protogame.IRenderPass) –
• postProcessingSource (Microsoft.Xna.Framework.Graphics.RenderTarget2D) –

public void EndRenderPass(IGameContext gameContext, IRenderContext renderContext, IRenderPass nextPass)

Parameters:

• gameContext (Protogame.IGameContext) –
• renderContext (Protogame.IRenderContext) –
• nextPass (Protogame.IRenderPass) –

Default3DDeferredRenderPass

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the I3DRenderPass service via dependency injection to access this functionality.

Information documented here may not be up to date.

class Default3DDeferredRenderPass : System.Object, I3DDeferredRenderPass, I3DBatchedRenderPass, I3DRenderPass, IRenderPass, Protogame.IRenderPassWithViewport

The implementation of T:Protogame.I3DRenderPass which uses deferred rendering.

readonly bool IsPostProcessingPass

readonly bool SkipWorldRenderBelow

readonly bool SkipWorldRenderAbove

readonly bool SkipEntityRender

readonly bool SkipEngineHookRender

readonly string EffectTechniqueName

System.Nullable<Viewport> Viewport

bool DebugGBuffer

bool ClearDepthBuffer

Clear the depth buffer before this render pass starts rendering. This allows you to alpha blend a 3D deferred render pass on top of a 2D render pass, without the 2D render pass interfering with the rendering of 3D objects.

bool ClearTarget

Clear the target before this render pass starts rendering. If your scene doesn’t fully cover the scene this should be turned on (unless you want what was previously rendered to remain on screen). This is on by default.

BlendState GBufferBlendState

The blend state to use when rendering the final G-buffer onto the backbuffer (or current render target). By default this is opaque, which is probably what you want if the deferred rendering pass is the first in the pipeline. However if you’re rendering 2D content underneath the 3D content, you should set this to something like F:Microsoft.Xna.Framework.Graphics.BlendState.AlphaBlend.

string Name

public void BeginRenderPass(IGameContext gameContext, IRenderContext renderContext, IRenderPass previousPass, RenderTarget2D postProcessingSource)

Parameters:

• gameContext (Protogame.IGameContext) –
• renderContext (Protogame.IRenderContext) –
• previousPass (Protogame.IRenderPass) –
• postProcessingSource (Microsoft.Xna.Framework.Graphics.RenderTarget2D) –

public void EndRenderPass(IGameContext gameContext, IRenderContext renderContext, IRenderPass nextPass)

Parameters:

• gameContext (Protogame.IGameContext) –
• renderContext (Protogame.IRenderContext) –
• nextPass (Protogame.IRenderPass) –

Default3DForwardRenderPass

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the I3DRenderPass service via dependency injection to access this functionality.

Information documented here may not be up to date.

class Default3DForwardRenderPass : System.Object, I3DForwardRenderPass, I3DBatchedRenderPass, I3DRenderPass, IRenderPass, Protogame.IRenderPassWithViewport

The implementation of T:Protogame.I3DRenderPass which uses forward rendering.

readonly bool IsPostProcessingPass

readonly bool SkipWorldRenderBelow

readonly bool SkipWorldRenderAbove

readonly bool SkipEntityRender

readonly bool SkipEngineHookRender

readonly string EffectTechniqueName

System.Nullable<Viewport> Viewport

string Name

public void BeginRenderPass(IGameContext gameContext, IRenderContext renderContext, IRenderPass previousPass, RenderTarget2D postProcessingSource)

Parameters:

• gameContext (Protogame.IGameContext) –
• renderContext (Protogame.IRenderContext) –
• previousPass (Protogame.IRenderPass) –
• postProcessingSource (Microsoft.Xna.Framework.Graphics.RenderTarget2D) –

public void EndRenderPass(IGameContext gameContext, IRenderContext renderContext, IRenderPass nextPass)

Parameters:

• gameContext (Protogame.IGameContext) –
• renderContext (Protogame.IRenderContext) –
• nextPass (Protogame.IRenderPass) –

DefaultBlurPostProcessingRenderPass

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the IBlurPostProcessingRenderPass service via dependency injection to access this functionality.

Information documented here may not be up to date.

class DefaultBlurPostProcessingRenderPass : System.Object, IBlurPostProcessingRenderPass, IRenderPass, Protogame.IRenderPassWithViewport

The default implementation of an T:Protogame.IBlurPostProcessingRenderPass.

readonly bool IsPostProcessingPass

readonly bool SkipWorldRenderBelow

readonly bool SkipWorldRenderAbove

readonly bool SkipEntityRender

readonly bool SkipEngineHookRender

readonly string EffectTechniqueName

System.Nullable<Viewport> Viewport

int Iterations

Gets or sets the number of blur iterations to apply.

string Name

public void BeginRenderPass(IGameContext gameContext, IRenderContext renderContext, IRenderPass previousPass, RenderTarget2D postProcessingSource)

Parameters:

• gameContext (Protogame.IGameContext) –
• renderContext (Protogame.IRenderContext) –
• previousPass (Protogame.IRenderPass) –
• postProcessingSource (Microsoft.Xna.Framework.Graphics.RenderTarget2D) –

public void EndRenderPass(IGameContext gameContext, IRenderContext renderContext, IRenderPass nextPass)

Parameters:

• gameContext (Protogame.IGameContext) –
• renderContext (Protogame.IRenderContext) –
• nextPass (Protogame.IRenderPass) –

DefaultCanvasRenderPass

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the ICanvasRenderPass service via dependency injection to access this functionality.

Information documented here may not be up to date.

class DefaultCanvasRenderPass : System.Object, ICanvasRenderPass, IRenderPass, Protogame.IRenderPassWithViewport

The default implementation of an T:Protogame.ICanvasRenderPass.

readonly bool IsPostProcessingPass

readonly bool SkipWorldRenderBelow

readonly bool SkipWorldRenderAbove

readonly bool SkipEntityRender

readonly bool SkipEngineHookRender

readonly string EffectTechniqueName

System.Nullable<Viewport> Viewport

SpriteSortMode TextureSortMode

string Name

public void BeginRenderPass(IGameContext gameContext, IRenderContext renderContext, IRenderPass previousPass, RenderTarget2D postProcessingSource)

Parameters:

• gameContext (Protogame.IGameContext) –
• renderContext (Protogame.IRenderContext) –
• previousPass (Protogame.IRenderPass) –
• postProcessingSource (Microsoft.Xna.Framework.Graphics.RenderTarget2D) –

public void EndRenderPass(IGameContext gameContext, IRenderContext renderContext, IRenderPass nextPass)

Parameters:

• gameContext (Protogame.IGameContext) –
• renderContext (Protogame.IRenderContext) –
• nextPass (Protogame.IRenderPass) –

DefaultCaptureCopyPostProcessingRenderPass

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the ICaptureCopyPostProcessingRenderPass service via dependency injection to access this functionality.

Information documented here may not be up to date.

class DefaultCaptureCopyPostProcessingRenderPass : System.Object, ICaptureCopyPostProcessingRenderPass, IRenderPass

The default implementation of an T:Protogame.ICaptureCopyPostProcessingRenderPass.

readonly bool IsPostProcessingPass

readonly bool SkipWorldRenderBelow

readonly bool SkipWorldRenderAbove

readonly bool SkipEntityRender

readonly bool SkipEngineHookRender

readonly string EffectTechniqueName

string Name

readonly RenderTarget2D CapturedRenderTarget

public void BeginRenderPass(IGameContext gameContext, IRenderContext renderContext, IRenderPass previousPass, RenderTarget2D postProcessingSource)

Parameters:

• gameContext (Protogame.IGameContext) –
• renderContext (Protogame.IRenderContext) –
• previousPass (Protogame.IRenderPass) –
• postProcessingSource (Microsoft.Xna.Framework.Graphics.RenderTarget2D) –

public void EndRenderPass(IGameContext gameContext, IRenderContext renderContext, IRenderPass nextPass)

Parameters:

• gameContext (Protogame.IGameContext) –
• renderContext (Protogame.IRenderContext) –
• nextPass (Protogame.IRenderPass) –

DefaultCaptureInlinePostProcessingRenderPass

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the ICaptureInlinePostProcessingRenderPass service via dependency injection to access this functionality.

Information documented here may not be up to date.

class DefaultCaptureInlinePostProcessingRenderPass : System.Object, ICaptureInlinePostProcessingRenderPass, IRenderPass

The default implementation of an T:Protogame.ICaptureInlinePostProcessingRenderPass.

readonly bool IsPostProcessingPass

readonly bool SkipWorldRenderBelow

readonly bool SkipWorldRenderAbove

readonly bool SkipEntityRender

readonly bool SkipEngineHookRender

readonly string EffectTechniqueName

string Name

System.Action<RenderTarget2D> RenderPipelineStateAvailable

public void BeginRenderPass(IGameContext gameContext, IRenderContext renderContext, IRenderPass previousPass, RenderTarget2D postProcessingSource)

Parameters:

• gameContext (Protogame.IGameContext) –
• renderContext (Protogame.IRenderContext) –
• previousPass (Protogame.IRenderPass) –
• postProcessingSource (Microsoft.Xna.Framework.Graphics.RenderTarget2D) –

public void EndRenderPass(IGameContext gameContext, IRenderContext renderContext, IRenderPass nextPass)

Parameters:

• gameContext (Protogame.IGameContext) –
• renderContext (Protogame.IRenderContext) –
• nextPass (Protogame.IRenderPass) –

DefaultCustomPostProcessingRenderPass

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the ICustomPostProcessingRenderPass service via dependency injection to access this functionality.

Information documented here may not be up to date.

class DefaultCustomPostProcessingRenderPass : System.Object, ICustomPostProcessingRenderPass, IRenderPass

A default implementation of T:Protogame.ICustomPostProcessingRenderPass.

readonly bool IsPostProcessingPass

readonly bool SkipWorldRenderBelow

readonly bool SkipWorldRenderAbove

readonly bool SkipEntityRender

readonly bool SkipEngineHookRender

readonly string EffectTechniqueName

readonly Protogame.IAssetReference<EffectAsset> Effect

string Name

public void BeginRenderPass(IGameContext gameContext, IRenderContext renderContext, IRenderPass previousPass, RenderTarget2D postProcessingSource)

Parameters:

• gameContext (Protogame.IGameContext) –
• renderContext (Protogame.IRenderContext) –
• previousPass (Protogame.IRenderPass) –
• postProcessingSource (Microsoft.Xna.Framework.Graphics.RenderTarget2D) –

public void EndRenderPass(IGameContext gameContext, IRenderContext renderContext, IRenderPass nextPass)

Parameters:

• gameContext (Protogame.IGameContext) –
• renderContext (Protogame.IRenderContext) –
• nextPass (Protogame.IRenderPass) –

public void SetValue(string name, bool value)

Parameters:

• name (string) –
• value (bool) –

public void SetValue(string name, int value)

Parameters:

• name (string) –
• value (int) –

public void SetValue(string name, Matrix value)

Parameters:

• name (string) –
• value (Microsoft.Xna.Framework.Matrix) –

public void SetValue(string name, Microsoft.Xna.Framework.Matrix[] value)

Parameters:

• name (string) –
• value (Microsoft.Xna.Framework.Matrix[]) –

public void SetValue(string name, Quaternion value)

Parameters:

• name (string) –
• value (Microsoft.Xna.Framework.Quaternion) –

public void SetValue(string name, float value)

Parameters:

• name (string) –
• value (float) –

public void SetValue(string name, System.Single[] value)

Parameters:

• name (string) –
• value (System.Single[]) –

public void SetValue(string name, Texture value)

Parameters:

• name (string) –
• value (Microsoft.Xna.Framework.Graphics.Texture) –

public void SetValue(string name, Vector2 value)

Parameters:

• name (string) –
• value (Microsoft.Xna.Framework.Vector2) –

public void SetValue(string name, Microsoft.Xna.Framework.Vector2[] value)

Parameters:

• name (string) –
• value (Microsoft.Xna.Framework.Vector2[]) –

public void SetValue(string name, Vector3 value)

Parameters:

• name (string) –
• value (Microsoft.Xna.Framework.Vector3) –

public void SetValue(string name, Microsoft.Xna.Framework.Vector3[] value)

Parameters:

• name (string) –
• value (Microsoft.Xna.Framework.Vector3[]) –

public void SetValue(string name, Vector4 value)

Parameters:

• name (string) –
• value (Microsoft.Xna.Framework.Vector4) –

public void SetValue(string name, Microsoft.Xna.Framework.Vector4[] value)

Parameters:

• name (string) –
• value (Microsoft.Xna.Framework.Vector4[]) –

DefaultGraphicsBlit

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the IGraphicsBlit service via dependency injection to access this functionality.

Information documented here may not be up to date.

class DefaultGraphicsBlit : System.Object, IGraphicsBlit

A default implementation of T:Protogame.IGraphicsBlit.

public void BlitMRT(IRenderContext renderContext, Texture2D source, Microsoft.Xna.Framework.Graphics.RenderTarget2D[] destinations, Protogame.IEffect shader, Protogame.IEffectParameterSet effectParameterSet, BlendState blendState, System.Nullable<Vector2> offset, System.Nullable<Vector2> size)

Parameters:

• renderContext (Protogame.IRenderContext) –
• source (Microsoft.Xna.Framework.Graphics.Texture2D) –
• destinations (Microsoft.Xna.Framework.Graphics.RenderTarget2D[]) –
• shader (Protogame.IEffect) –
• effectParameterSet (Protogame.IEffectParameterSet) –
• blendState (Microsoft.Xna.Framework.Graphics.BlendState) –
• offset (System.Nullable<Vector2>) –
• size (System.Nullable<Vector2>) –

public void Blit(IRenderContext renderContext, Texture2D source, RenderTarget2D destination, Protogame.IEffect shader, Protogame.IEffectParameterSet effectParameterSet, BlendState blendState, System.Nullable<Vector2> offset, System.Nullable<Vector2> size)

Parameters:

• renderContext (Protogame.IRenderContext) –
• source (Microsoft.Xna.Framework.Graphics.Texture2D) –
• destination (Microsoft.Xna.Framework.Graphics.RenderTarget2D) –
• shader (Protogame.IEffect) –
• effectParameterSet (Protogame.IEffectParameterSet) –
• blendState (Microsoft.Xna.Framework.Graphics.BlendState) –
• offset (System.Nullable<Vector2>) –
• size (System.Nullable<Vector2>) –

DefaultInvertPostProcessingRenderPass

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the IInvertPostProcessingRenderPass service via dependency injection to access this functionality.

Information documented here may not be up to date.

class DefaultInvertPostProcessingRenderPass : System.Object, IInvertPostProcessingRenderPass, IRenderPass

The default implementation of an T:Protogame.IInvertPostProcessingRenderPass.

readonly bool IsPostProcessingPass

readonly bool SkipWorldRenderBelow

readonly bool SkipWorldRenderAbove

readonly bool SkipEntityRender

readonly bool SkipEngineHookRender

readonly string EffectTechniqueName

string Name

public void BeginRenderPass(IGameContext gameContext, IRenderContext renderContext, IRenderPass previousPass, RenderTarget2D postProcessingSource)

Parameters:

• gameContext (Protogame.IGameContext) –
• renderContext (Protogame.IRenderContext) –
• previousPass (Protogame.IRenderPass) –
• postProcessingSource (Microsoft.Xna.Framework.Graphics.RenderTarget2D) –

public void EndRenderPass(IGameContext gameContext, IRenderContext renderContext, IRenderPass nextPass)

Parameters:

• gameContext (Protogame.IGameContext) –
• renderContext (Protogame.IRenderContext) –
• nextPass (Protogame.IRenderPass) –

DefaultRenderPipeline

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the IRenderPipeline service via dependency injection to access this functionality.

Information documented here may not be up to date.

class DefaultRenderPipeline : System.Object, IRenderPipeline

The default implementation of an T:Protogame.IRenderPipeline.

public void Render(IGameContext gameContext, IRenderContext renderContext)

Parameters:

• gameContext (Protogame.IGameContext) –
• renderContext (Protogame.IRenderContext) –

public IRenderPass AddFixedRenderPass(IRenderPass renderPass)

Parameters:

• renderPass (Protogame.IRenderPass) –

public void RemoveFixedRenderPass(IRenderPass renderPass)

Parameters:

• renderPass (Protogame.IRenderPass) –

public IRenderPass AppendTransientRenderPass(IRenderPass renderPass)

Parameters:

• renderPass (Protogame.IRenderPass) –

public IRenderPass GetCurrentRenderPass()

public bool IsFirstRenderPass()

DefaultRenderTargetBackBufferUtilities

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the IRenderTargetBackBufferUtilities service via dependency injection to access this functionality.

Information documented here may not be up to date.

class DefaultRenderTargetBackBufferUtilities : System.Object, IRenderTargetBackBufferUtilities

The default implementation of an T:Protogame.IRenderTargetBackBufferUtilities.

public RenderTarget2D UpdateRenderTarget(RenderTarget2D renderTarget, IGameContext gameContext)

Parameters:

• renderTarget (Microsoft.Xna.Framework.Graphics.RenderTarget2D) –
• gameContext (Protogame.IGameContext) –

public RenderTarget2D UpdateCustomRenderTarget(RenderTarget2D renderTarget, IGameContext gameContext, System.Nullable<SurfaceFormat> surfaceFormat, System.Nullable<DepthFormat> depthFormat, System.Nullable<Int32> multiSampleCount)

Parameters:

• renderTarget (Microsoft.Xna.Framework.Graphics.RenderTarget2D) –
• gameContext (Protogame.IGameContext) –
• surfaceFormat (System.Nullable<SurfaceFormat>) –
• depthFormat (System.Nullable<DepthFormat>) –
• multiSampleCount (System.Nullable<Int32>) –

public bool IsRenderTargetOutOfDate(RenderTarget2D renderTarget, IGameContext gameContext)

Parameters:

• renderTarget (Microsoft.Xna.Framework.Graphics.RenderTarget2D) –
• gameContext (Protogame.IGameContext) –

public bool IsCustomRenderTargetOutOfDate(RenderTarget2D renderTarget, IGameContext gameContext, System.Nullable<SurfaceFormat> surfaceFormat, System.Nullable<DepthFormat> depthFormat, System.Nullable<Int32> multiSampleCount)

Parameters:

• renderTarget (Microsoft.Xna.Framework.Graphics.RenderTarget2D) –
• gameContext (Protogame.IGameContext) –
• surfaceFormat (System.Nullable<SurfaceFormat>) –
• depthFormat (System.Nullable<DepthFormat>) –
• multiSampleCount (System.Nullable<Int32>) –

RenderPipelineRenderContext

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the IRenderContext service via dependency injection to access this functionality.

Information documented here may not be up to date.

class RenderPipelineRenderContext : System.Object, IRenderContext

The implementation of T:Protogame.IRenderContext which provides additional APIs for interacting with the render pipeline.

readonly BoundingFrustum BoundingFrustum

Gets the bounding frustum for the current view and projection matrixes.

Value:The bounding frustum for the current view and projection matrixes.

readonly GraphicsDevice GraphicsDevice

Gets the associated graphics device.

Value:The graphics device.

bool Is3DContext

Gets or sets a value indicating whether the world manager is currently rendering a 3D context. For games using a 2D world manager, this will always be false. For 3D games, world managers will do an initial 3D pass followed by a 2D pass that is rendered on top (for UI, etc.) In a 3D context, only I3DRenderUtilities can be used; in a 2D context, only I2DRenderUtilities can be used.

Value:Whether the rendering context is currently a 3D context.

bool IsRendering

Gets a value indicating whether the game is currently rendering in either the render pipeline or the backbuffer. This value will always be true within any method call that occurs below M:Microsoft.Xna.Framework.Game.Draw(Microsoft.Xna.Framework.GameTime) in the call stack. When you are rendering, certain operations can not be performed, in particular, operations which reset the graphics device like resizing the game window.

Vector3 CameraPosition

Gets or sets the last known camera position. The value of this property is set internally by cameras so that the camera position is known when lighting effects are applied. Setting this property from user code will not actually update the camera position or modify projection parameters; it will only impact the way lights are rendered.

Vector3 CameraLookAt

Gets or sets the last known camera look at vector. The value of this property is set internally by cameras so that the camera look at vector is known when lighting effects are applied. Setting this property from user code will not actually update the camera look at vector or modify projection parameters; it will only impact the way lights are rendered.

Matrix Projection

Gets or sets the projection matrix for 3D rendering.

Value:The projection matrix for 3D rendering.

readonly Texture2D SingleWhitePixel

Gets a texture representing a single white pixel.

Value:The single white pixel.

readonly SpriteBatch SpriteBatch

Gets a sprite batch associated with the current device, upon which 2D rendering is performed.

Value:The sprite batch.

Matrix View

Gets or sets the view matrix for 3D rendering.

Value:The view matrix for 3D rendering.

Matrix World

Gets or sets the world matrix for 3D rendering.

Value:The world matrix for 3D rendering.

readonly IRenderPass CurrentRenderPass

Gets the current render pass that is being used.

Value:The current render pass that is being used.

public void PopRenderTarget()

Pops the current render target from the current rendering context. If there are no more render targets in the stack after this call, then the rendering will default back to rendering to the back buffer.

public void PushRenderTarget(RenderTargetBinding renderTarget)

Push a render target onto the current rendering context, making it the active target for rendering. By using the PushRenderTarget / PopRenderTarget methods, this allows you to safely chain render target switches, without risk of losing the previous render target. An example of where this can be used is if you want to capture the next frame, you can simply start with a PushRenderTarget and as long as all other render target switching uses these methods or respects the previous render target, then everything will be captured as intended.

Parameters:

• renderTarget (Microsoft.Xna.Framework.Graphics.RenderTargetBinding) – The render target instance to make active.

public void PushRenderTarget(Microsoft.Xna.Framework.Graphics.RenderTargetBinding[] renderTargets)

Push an array of render targets onto the current rendering context, making them the active target for rendering. By using the PushRenderTarget / PopRenderTarget methods, this allows you to safely chain render target switches, without risk of losing the previous render target.

Parameters:

• renderTargets (Microsoft.Xna.Framework.Graphics.RenderTargetBinding[]) – The render targets to make active.

public void Render(IGameContext context)

The render.

Parameters:

• context (Protogame.IGameContext) – The context.

public IRenderPass AddFixedRenderPass(IRenderPass renderPass)

Adds the specified render pass to the render pipeline permanently. This render pass will take effect after the start of the next frame.

Parameters:

• renderPass (Protogame.IRenderPass) – The render pass to add.

Returns:

The render pass that was given to this function. This return value is for convenience only, so that you may construct and add a render pass in a single statement, while obtaining a reference to it if you need to modify it’s values or call M:Protogame.RenderPipelineRenderContext.RemoveFixedRenderPass(Protogame.IRenderPass) later. The render pass is not modified by this function.

public void RemoveFixedRenderPass(IRenderPass renderPass)

Removes the specified render pass from the render pipeline.

Parameters:

• renderPass (Protogame.IRenderPass) – The render pass to remove.

public IRenderPass AppendTransientRenderPass(IRenderPass renderPass)

Append the specified render pass to the render pipeline for this frame only. This is method that allows you to temporarily add additional render passes to a frame.

If all standard (non-post-processing) render passes have finished post-processing has begun and this method is given a standard render pass, it will have no effect.

Render passes that were appended can not be removed with M:Protogame.RenderPipelineRenderContext.RemoveFixedRenderPass(Protogame.IRenderPass).

Parameters:

• renderPass (Protogame.IRenderPass) – The render pass to add.

Returns:

The render pass that was given to this function. This return value is for convenience only, so that you may construct and add a render pass in a single statement, while obtaining a reference to it if you need to modify it’s value. The render pass is not modified by this function.

public bool IsCurrentRenderPass<T>()

Returns whether or not the current render pass is of the specified type.

Type Parameters:  

• T – The type to check the render pass against.

Returns:

Whether or not the current render pass is of the specified type.

public bool IsCurrentRenderPass<T>(ref Protogame.T currentRenderPass)

Type Parameters:  

• T –

Parameters:

• (ref) currentRenderPass (Protogame.T) –

public Protogame.T GetCurrentRenderPass<T>()

Returns the current render pass as the type T.

Type Parameters:  

• T – The type of render pass to return.

Returns:

The current render pass as the type T.

public bool IsFirstRenderPass()

Returns whether this is the first render pass being performed. You can use this method to isolate render logic that should only occur once per frame (such as appending transient render passes).

Returns:Whether this is the first render pass being performed.

RenderPipelineWorldManager

Warning

This documentation is for an internal class. This class is not intended to be used by developers, and is used internally within the engine to provide functionality.

Information documented here may not be up to date.

class RenderPipelineWorldManager : System.Object, IWorldManager

An implementation of T:Protogame.IWorldManager which uses the new rendering pipeline in Protogame. You should use this as the world manager for all new games going forward, or make your game inherit from T:Protogame.CoreGame`1, which will default to this world manager.

readonly IRenderPipeline RenderPipeline

public void Render<T>(Protogame.T game)

Type Parameters:  

• T –

Parameters:

• game (Protogame.T) –

public void Update<T>(Protogame.T game)

Type Parameters:  

• T –

Parameters:

• game (Protogame.T) –

Default2DRenderUtilities

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the I2DRenderUtilities service via dependency injection to access this functionality.

Information documented here may not be up to date.

class Default2DRenderUtilities : System.Object, I2DRenderUtilities

An implementation of T:Protogame.I2DRenderUtilities.

public Vector2 MeasureText(IRenderContext context, string text, Protogame.IAssetReference<FontAsset> font)

Parameters:

• context (Protogame.IRenderContext) –
• text (string) –
• font (Protogame.IAssetReference<FontAsset>) –

public void RenderLine(IRenderContext context, Vector2 start, Vector2 end, Color color, float width)

Parameters:

• context (Protogame.IRenderContext) –
• start (Microsoft.Xna.Framework.Vector2) –
• end (Microsoft.Xna.Framework.Vector2) –
• color (Microsoft.Xna.Framework.Color) –
• width (float) –

public void RenderRectangle(IRenderContext context, Rectangle rectangle, Color color, bool filled)

Parameters:

• context (Protogame.IRenderContext) –
• rectangle (Microsoft.Xna.Framework.Rectangle) –
• color (Microsoft.Xna.Framework.Color) –
• filled (bool) –

public void RenderText(IRenderContext context, Vector2 position, string text, Protogame.IAssetReference<FontAsset> font, HorizontalAlignment horizontalAlignment, VerticalAlignment verticalAlignment, System.Nullable<Color> textColor, bool renderShadow, System.Nullable<Color> shadowColor)

Parameters:

• context (Protogame.IRenderContext) –
• position (Microsoft.Xna.Framework.Vector2) –
• text (string) –
• font (Protogame.IAssetReference<FontAsset>) –
• horizontalAlignment (Protogame.HorizontalAlignment) –
• verticalAlignment (Protogame.VerticalAlignment) –
• textColor (System.Nullable<Color>) –
• renderShadow (bool) –
• shadowColor (System.Nullable<Color>) –

public void RenderTexture(IRenderContext context, Vector2 position, Protogame.IAssetReference<TextureAsset> texture, System.Nullable<Vector2> size, System.Nullable<Color> color, float rotation, System.Nullable<Vector2> rotationAnchor, bool flipHorizontally, bool flipVertically, System.Nullable<Rectangle> sourceArea)

Parameters:

• context (Protogame.IRenderContext) –
• position (Microsoft.Xna.Framework.Vector2) –
• texture (Protogame.IAssetReference<TextureAsset>) –
• size (System.Nullable<Vector2>) –
• color (System.Nullable<Color>) –
• rotation (float) –
• rotationAnchor (System.Nullable<Vector2>) –
• flipHorizontally (bool) –
• flipVertically (bool) –
• sourceArea (System.Nullable<Rectangle>) –

public void RenderTexture(IRenderContext context, Vector2 position, Texture2D texture, System.Nullable<Vector2> size, System.Nullable<Color> color, float rotation, System.Nullable<Vector2> rotationAnchor, bool flipHorizontally, bool flipVertically, System.Nullable<Rectangle> sourceArea)

Parameters:

• context (Protogame.IRenderContext) –
• position (Microsoft.Xna.Framework.Vector2) –
• texture (Microsoft.Xna.Framework.Graphics.Texture2D) –
• size (System.Nullable<Vector2>) –
• color (System.Nullable<Color>) –
• rotation (float) –
• rotationAnchor (System.Nullable<Vector2>) –
• flipHorizontally (bool) –
• flipVertically (bool) –
• sourceArea (System.Nullable<Rectangle>) –

public void RenderCircle(IRenderContext context, Vector2 center, int radius, Color color, bool filled)

Parameters:

• context (Protogame.IRenderContext) –
• center (Microsoft.Xna.Framework.Vector2) –
• radius (int) –
• color (Microsoft.Xna.Framework.Color) –
• filled (bool) –

public void SuspendSpriteBatch(IRenderContext renderContext)

Parameters:

• renderContext (Protogame.IRenderContext) –

public void ResumeSpriteBatch(IRenderContext renderContext)

Parameters:

• renderContext (Protogame.IRenderContext) –

Default3DRenderUtilities

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the I3DRenderUtilities service via dependency injection to access this functionality.

Information documented here may not be up to date.

class Default3DRenderUtilities : System.Object, I3DRenderUtilities

The default implementation of T:Protogame.I3DRenderUtilities.

public Vector2 MeasureText(IRenderContext context, string text, Protogame.IAssetReference<FontAsset> font)

Parameters:

• context (Protogame.IRenderContext) –
• text (string) –
• font (Protogame.IAssetReference<FontAsset>) –

public void RenderLine(IRenderContext context, Protogame.IEffect effect, Protogame.IEffectParameterSet effectParameterSet, Vector3 start, Vector3 end, Color color)

Parameters:

• context (Protogame.IRenderContext) –
• effect (Protogame.IEffect) –
• effectParameterSet (Protogame.IEffectParameterSet) –
• start (Microsoft.Xna.Framework.Vector3) –
• end (Microsoft.Xna.Framework.Vector3) –
• color (Microsoft.Xna.Framework.Color) –

public void RenderLine(IRenderContext context, Protogame.IEffect effect, Protogame.IEffectParameterSet effectParameterSet, Vector3 start, Vector3 end, TextureAsset texture, Vector2 startUV, Vector2 endUV)

Parameters:

• context (Protogame.IRenderContext) –
• effect (Protogame.IEffect) –
• effectParameterSet (Protogame.IEffectParameterSet) –
• start (Microsoft.Xna.Framework.Vector3) –
• end (Microsoft.Xna.Framework.Vector3) –
• texture (Protogame.TextureAsset) –
• startUV (Microsoft.Xna.Framework.Vector2) –
• endUV (Microsoft.Xna.Framework.Vector2) –

public void RenderRectangle(IRenderContext context, Protogame.IEffect effect, Protogame.IEffectParameterSet effectParameterSet, Vector3 start, Vector3 end, Color color, bool filled)

Parameters:

• context (Protogame.IRenderContext) –
• effect (Protogame.IEffect) –
• effectParameterSet (Protogame.IEffectParameterSet) –
• start (Microsoft.Xna.Framework.Vector3) –
• end (Microsoft.Xna.Framework.Vector3) –
• color (Microsoft.Xna.Framework.Color) –
• filled (bool) –

public void RenderText(IRenderContext context, Protogame.IEffect effect, Protogame.IEffectParameterSet effectParameterSet, Matrix matrix, string text, Protogame.IAssetReference<FontAsset> font, HorizontalAlignment horizontalAlignment, VerticalAlignment verticalAlignment, System.Nullable<Color> textColor, bool renderShadow, System.Nullable<Color> shadowColor)

Parameters:

• context (Protogame.IRenderContext) –
• effect (Protogame.IEffect) –
• effectParameterSet (Protogame.IEffectParameterSet) –
• matrix (Microsoft.Xna.Framework.Matrix) –
• text (string) –
• font (Protogame.IAssetReference<FontAsset>) –
• horizontalAlignment (Protogame.HorizontalAlignment) –
• verticalAlignment (Protogame.VerticalAlignment) –
• textColor (System.Nullable<Color>) –
• renderShadow (bool) –
• shadowColor (System.Nullable<Color>) –

public void RenderTexture(IRenderContext context, Protogame.IEffect effect, Protogame.IEffectParameterSet effectParameterSet, Matrix matrix, Protogame.IAssetReference<TextureAsset> texture, System.Nullable<Color> color, bool flipHorizontally, bool flipVertically, System.Nullable<Rectangle> sourceArea)

Parameters:

• context (Protogame.IRenderContext) –
• effect (Protogame.IEffect) –
• effectParameterSet (Protogame.IEffectParameterSet) –
• matrix (Microsoft.Xna.Framework.Matrix) –
• texture (Protogame.IAssetReference<TextureAsset>) –
• color (System.Nullable<Color>) –
• flipHorizontally (bool) –
• flipVertically (bool) –
• sourceArea (System.Nullable<Rectangle>) –

public void RenderCube(IRenderContext context, Protogame.IEffect effect, Protogame.IEffectParameterSet effectParameterSet, Matrix transform, Color color)

Parameters:

• context (Protogame.IRenderContext) –
• effect (Protogame.IEffect) –
• effectParameterSet (Protogame.IEffectParameterSet) –
• transform (Microsoft.Xna.Framework.Matrix) –
• color (Microsoft.Xna.Framework.Color) –

public void RenderCube(IRenderContext context, Protogame.IEffect effect, Protogame.IEffectParameterSet effectParameterSet, Matrix transform, TextureAsset texture, Vector2 topLeftUV, Vector2 bottomRightUV)

Parameters:

• context (Protogame.IRenderContext) –
• effect (Protogame.IEffect) –
• effectParameterSet (Protogame.IEffectParameterSet) –
• transform (Microsoft.Xna.Framework.Matrix) –
• texture (Protogame.TextureAsset) –
• topLeftUV (Microsoft.Xna.Framework.Vector2) –
• bottomRightUV (Microsoft.Xna.Framework.Vector2) –

public void RenderPlane(IRenderContext context, Protogame.IEffect effect, Protogame.IEffectParameterSet effectParameterSet, Matrix transform, Color color)

Parameters:

• context (Protogame.IRenderContext) –
• effect (Protogame.IEffect) –
• effectParameterSet (Protogame.IEffectParameterSet) –
• transform (Microsoft.Xna.Framework.Matrix) –
• color (Microsoft.Xna.Framework.Color) –

public void RenderPlane(IRenderContext context, Protogame.IEffect effect, Protogame.IEffectParameterSet effectParameterSet, Matrix transform, TextureAsset texture, Vector2 topLeftUV, Vector2 bottomRightUV)

Parameters:

• context (Protogame.IRenderContext) –
• effect (Protogame.IEffect) –
• effectParameterSet (Protogame.IEffectParameterSet) –
• transform (Microsoft.Xna.Framework.Matrix) –
• texture (Protogame.TextureAsset) –
• topLeftUV (Microsoft.Xna.Framework.Vector2) –
• bottomRightUV (Microsoft.Xna.Framework.Vector2) –

public void RenderCircle(IRenderContext context, Protogame.IEffect effect, Protogame.IEffectParameterSet effectParameterSet, Matrix transform, Vector2 center, int radius, Color color, bool filled)

Parameters:

• context (Protogame.IRenderContext) –
• effect (Protogame.IEffect) –
• effectParameterSet (Protogame.IEffectParameterSet) –
• transform (Microsoft.Xna.Framework.Matrix) –
• center (Microsoft.Xna.Framework.Vector2) –
• radius (int) –
• color (Microsoft.Xna.Framework.Color) –
• filled (bool) –

DefaultHivePublicAuthentication

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the IHivePublicAuthentication service via dependency injection to access this functionality.

Information documented here may not be up to date.

class DefaultHivePublicAuthentication : System.Object, IHivePublicAuthentication

The default implementation of T:Protogame.IHivePublicAuthentication.

string PublicApiKey

ImageSourceFromRGBAArray

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the IImageSource service via dependency injection to access this functionality.

Information documented here may not be up to date.

class ImageSourceFromRGBAArray : System.Object, IImageSource

An image source that uses an RGBA array.

public System.Byte[] GetSourceAsBytes(ref int width, ref int height)

Parameters:

• (ref) width (int) –
• (ref) height (int) –

ImageSourceFromTexture

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the IImageSource service via dependency injection to access this functionality.

Information documented here may not be up to date.

class ImageSourceFromTexture : System.Object, IImageSource

An image source that uses an in-memory texture.

public System.Byte[] GetSourceAsBytes(ref int width, ref int height)

Parameters:

• (ref) width (int) –
• (ref) height (int) –

ThreadedColorInImageDetection

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the IColorInImageDetection service via dependency injection to access this functionality.

Information documented here may not be up to date.

class ThreadedColorInImageDetection : System.Object, IColorInImageDetection, System.IDisposable

An implementation of T:Protogame.IColorInImageDetection that uses a background thread for performing analysis.

float GlobalSensitivity

int ChunkSize

public string GetNameForColor(Protogame.ISelectedColorHandle handle)

Parameters:

• handle (Protogame.ISelectedColorHandle) –

public Color GetValueForColor(Protogame.ISelectedColorHandle handle)

Parameters:

• handle (Protogame.ISelectedColorHandle) –

public Protogame.ISelectedColorHandle RegisterColorForAnalysis(Color color, string name)

Parameters:

• color (Microsoft.Xna.Framework.Color) –
• name (string) –

public System.Int32[,] GetUnlockedResultsForColor(Protogame.ISelectedColorHandle handle)

Parameters:

• handle (Protogame.ISelectedColorHandle) –

public float GetSensitivityForColor(Protogame.ISelectedColorHandle handle)

Parameters:

• handle (Protogame.ISelectedColorHandle) –

public int GetTotalDetectedForColor(Protogame.ISelectedColorHandle handle)

Parameters:

• handle (Protogame.ISelectedColorHandle) –

public void Start()

public void Dispose()

ATFLevelReader

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the ILevelReader service via dependency injection to access this functionality.

Information documented here may not be up to date.

class ATFLevelReader : System.Object, ILevelReader

The level reader for levels saved from an ATF level editor.

public System.Collections.Generic.IEnumerable<IEntity> Read(System.IO.Stream stream, System.Object context, System.Func<IPlan, Object, Boolean> filter)

Parameters:

• stream (System.IO.Stream) –
• context (System.Object) –
• Object, Boolean> filter (System.Func<IPlan,) –

public System.Collections.Generic.IEnumerable<IEntity> Read(System.IO.Stream stream, System.Object context)

Parameters:

• stream (System.IO.Stream) –
• context (System.Object) –

DefaultLevelManager

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the ILevelManager service via dependency injection to access this functionality.

Information documented here may not be up to date.

class DefaultLevelManager : System.Object, ILevelManager

The default level manager.

public void Load(System.Object context, Protogame.LevelAsset levelAsset)

Loads a level entity into the game hierarchy, with the specified context as the place to load entities. Normally you’ll pass in the game world here, but you don’t have to. For example, if you wanted to load the level into an entity group, you would pass the entity group as the context instead.

Parameters:

• context (System.Object) – Usually the current game world, but can be any object in the hierarchy.
• levelAsset (Protogame.LevelAsset) – The level to load.

public void Load(System.Object context, Protogame.LevelAsset levelAsset, System.Func<IPlan, Object, Boolean> filter)

Parameters:

• context (System.Object) –
• levelAsset (Protogame.LevelAsset) –
• Object, Boolean> filter (System.Func<IPlan,) –

public System.Threading.Tasks.Task LoadAsync(System.Object context, Protogame.LevelAsset levelAsset)

Parameters:

• context (System.Object) –
• levelAsset (Protogame.LevelAsset) –

public System.Threading.Tasks.Task LoadAsync(System.Object context, Protogame.LevelAsset levelAsset, System.Func<IPlan, Object, Boolean> filter)

Parameters:

• context (System.Object) –
• levelAsset (Protogame.LevelAsset) –
• Object, Boolean> filter (System.Func<IPlan,) –

DefaultTileset

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the ITileset service via dependency injection to access this functionality.

Information documented here may not be up to date.

class DefaultTileset : System.Object, ITileset, IEntity, IHasTransform

The default tileset.

IEntity Item

readonly Protogame.ITransform Transform

readonly Protogame.IFinalTransform FinalTransform

public void Render(IGameContext gameContext, IRenderContext renderContext)

The render.

Parameters:

• gameContext (Protogame.IGameContext) – The game context.
• renderContext (Protogame.IRenderContext) – The render context.

public void SetSize(Vector2 cellSize, Vector2 tilesetSize)

The set size.

Parameters:

• cellSize (Microsoft.Xna.Framework.Vector2) – The cell size.
• tilesetSize (Microsoft.Xna.Framework.Vector2) – The tileset size.

public void Update(IGameContext gameContext, IUpdateContext updateContext)

The update.

Parameters:

• gameContext (Protogame.IGameContext) – The game context.
• updateContext (Protogame.IUpdateContext) – The update context.

OgmoLevelReader

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the ILevelReader service via dependency injection to access this functionality.

Information documented here may not be up to date.

class OgmoLevelReader : System.Object, ILevelReader

The ogmo level reader.

public System.Collections.Generic.IEnumerable<IEntity> Read(System.IO.Stream stream, System.Object context, System.Func<IPlan, Object, Boolean> filter)

Parameters:

• stream (System.IO.Stream) –
• context (System.Object) –
• Object, Boolean> filter (System.Func<IPlan,) –

public System.Collections.Generic.IEnumerable<IEntity> Read(System.IO.Stream stream, System.Object context)

Creates the entities from the stream.

Parameters:

• stream (System.IO.Stream) – The stream which contains an Ogmo Editor level.
• context (System.Object) – The context in which entities are being spawned in the hierarchy. This is usually the current world, but it doesn’t have to be (e.g. if you wanted to load a level under an entity group, you would pass the entity group here).

Returns:

A list of entities to spawn within the world.

DefaultNetworkEventContext

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the INetworkEventContext service via dependency injection to access this functionality.

Information documented here may not be up to date.

class DefaultNetworkEventContext : System.Object, INetworkEventContext

The default implementation of T:Protogame.INetworkEventContext.

DefaultPhysicsEventContext

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the IPhysicsEventContext service via dependency injection to access this functionality.

Information documented here may not be up to date.

class DefaultPhysicsEventContext : System.Object, IPhysicsEventContext

The default implementation of T:Protogame.IPhysicsEventContext.

DefaultPhysicsWorldControl

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the IPhysicsWorldControl service via dependency injection to access this functionality.

Information documented here may not be up to date.

class DefaultPhysicsWorldControl : System.Object, IPhysicsWorldControl

The default implementation of T:Protogame.IPhysicsWorldControl.

Vector3 Gravity

Jitter.Dynamics.MaterialCoefficientMixingType MaterialCoefficientMixing

System.Func<RigidBody, RigidBody, Boolean> ConsiderAngularVelocityCallback

System.Func<RigidBody, RigidBody, Single> CalculateStaticFrictionCallback

System.Func<RigidBody, RigidBody, Single> CalculateDynamicFrictionCallback

System.Func<RigidBody, RigidBody, Single> CalculateRestitutionCallback

bool EnableSpeculativeContacts

public void SyncPendingChanges()

DefaultPoolManager

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the IPoolManager service via dependency injection to access this functionality.

Information documented here may not be up to date.

class DefaultPoolManager : System.Object, IPoolManager

The default implementation of an T:Protogame.IPoolManager.

public IPool<T> NewPool<T>(string name, int size, System.Action<T> resetAction)

Type Parameters:  

• T –

Parameters:

• name (string) –
• size (int) –
• resetAction (System.Action<T>) –

public IPool<T> NewPool<T>(string name, int size, System.Func<T> factoryFunc, System.Action<T> resetAction)

Type Parameters:  

• T –

Parameters:

• name (string) –
• size (int) –
• factoryFunc (System.Func<T>) –
• resetAction (System.Action<T>) –

public IPool<T> NewPool<T>(string name, int size, System.Func<T> factoryFunc, System.Action<T> resetAction, System.Action<T> newAction)

Type Parameters:  

• T –

Parameters:

• name (string) –
• size (int) –
• factoryFunc (System.Func<T>) –
• resetAction (System.Action<T>) –
• newAction (System.Action<T>) –

public IPool<T> NewScalingPool<T>(string name, int increment, System.Action<T> resetAction)

Type Parameters:  

• T –

Parameters:

• name (string) –
• increment (int) –
• resetAction (System.Action<T>) –

public IPool<T> NewScalingPool<T>(string name, int increment, System.Func<T> factoryFunc, System.Action<T> resetAction)

Type Parameters:  

• T –

Parameters:

• name (string) –
• increment (int) –
• factoryFunc (System.Func<T>) –
• resetAction (System.Action<T>) –

public IPool<T> NewScalingPool<T>(string name, int increment, System.Func<T> factoryFunc, System.Action<T> resetAction, System.Action<T> newAction)

Type Parameters:  

• T –

Parameters:

• name (string) –
• increment (int) –
• factoryFunc (System.Func<T>) –
• resetAction (System.Action<T>) –
• newAction (System.Action<T>) –

public Protogame.IPool<T[]> NewArrayPool<T>(string name, int size, int arraySize, System.Action<T[]> resetAction)

Type Parameters:  

• T –

Parameters:

• name (string) –
• size (int) –
• arraySize (int) –
• resetAction (System.Action<T[]>) –

public Protogame.IPool<T[]> NewScalingArrayPool<T>(string name, int increment, int arraySize, System.Action<T[]> resetAction)

Type Parameters:  

• T –

Parameters:

• name (string) –
• increment (int) –
• arraySize (int) –
• resetAction (System.Action<T[]>) –

IRawPool

Warning

This documentation is for an internal class. This class is not intended to be used by developers, and is used internally within the engine to provide functionality.

Information documented here may not be up to date.

interface IRawPool

The raw interface for accessing a memory pool. This interface is only used internally.

readonly string Name

readonly int NextAvailable

readonly int NextReturn

readonly int Free

readonly int Total

Pool<T>

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the Protogame.IPool service via dependency injection to access this functionality.

Information documented here may not be up to date.

class Pool<T> : System.Object, IPool<T>, IRawPool

An implementation of an T:Protogame.IPool`1 which manages an array of objects. This implementation does not allocate the objects for you; you need to initialize an array of objects which is then used in this implementation.

It’s recommended that you use T:Protogame.ScalingPool`1 instead, creating it via T:Protogame.IPoolManager.

Type Parameters:  

• T –

readonly int Free

readonly int Total

readonly string Name

readonly int NextAvailable

readonly int NextReturn

public Protogame.T Get()

public void Release(Protogame.T instance)

Parameters:

• instance (Protogame.T) –

public void ReleaseAll()

ScalingPool<T>

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the Protogame.IPool service via dependency injection to access this functionality.

Information documented here may not be up to date.

class ScalingPool<T> : System.Object, IPool<T>, IRawPool

An implementation of an T:Protogame.IPool`1 which is capable of scaling the capacity as more objects are needed. Unlike standard allocation and collection, this implementation allocates objects in an incremental block amount.

Type Parameters:  

• T –

readonly int Free

readonly string Name

readonly int NextAvailable

readonly int NextReturn

readonly int Total

public Protogame.T Get()

public void Release(Protogame.T instance)

Parameters:

• instance (Protogame.T) –

public void ReleaseAll()

DefaultSensorEngine

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the ISensorEngine service via dependency injection to access this functionality.

Information documented here may not be up to date.

class DefaultSensorEngine : System.Object, ISensorEngine

The default implementation of an T:Protogame.ISensorEngine.

public void Render(IGameContext gameContext, IRenderContext renderContext)

Internally called by T:Protogame.SensorEngineHook to update sensors during the render step.

Parameters:

• gameContext (Protogame.IGameContext) – The current game context.
• renderContext (Protogame.IRenderContext) – The current render context.

public void Update(IGameContext gameContext, IUpdateContext updateContext)

Internally called by T:Protogame.SensorEngineHook to update sensors during the update step.

Parameters:

• gameContext (Protogame.IGameContext) – The current game context.
• updateContext (Protogame.IUpdateContext) – The current update context.

public void Register(ISensor sensor)

Registers a hardware sensor with the sensor engine, ensuring that it is updated as the game runs.

Parameters:

• sensor (Protogame.ISensor) – The hardware sensor to register.

public void Deregister(ISensor sensor)

Deregisters a hardware sensor from the sensor engine, ensuring that it is no longer updated as the game runs.

Parameters:

• sensor (Protogame.ISensor) – The hardware sensor to deregister.

DirectShowCameraSensor

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the ICameraSensor service via dependency injection to access this functionality.

Information documented here may not be up to date.

class DirectShowCameraSensor : System.Object, ICameraSensor, ISensor

An implementation of T:Protogame.ICameraSensor which uses DirectShow to provide access to camera devices on Windows.

readonly Texture2D VideoCaptureFrame

readonly System.Byte[] VideoCaptureUnlockedRGBA

readonly System.Nullable<Int32> VideoCaptureWidth

readonly System.Nullable<Int32> VideoCaptureHeight

ICamera ActiveCamera

public System.Collections.Generic.List<ICamera> GetAvailableCameras()

public void Render(IGameContext gameContext, IRenderContext renderContext)

Parameters:

• gameContext (Protogame.IGameContext) –
• renderContext (Protogame.IRenderContext) –

public void Update(IGameContext gameContext, IUpdateContext updateContext)

Parameters:

• gameContext (Protogame.IGameContext) –
• updateContext (Protogame.IUpdateContext) –

NullCameraSensor

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the ICameraSensor service via dependency injection to access this functionality.

Information documented here may not be up to date.

class NullCameraSensor : System.Object, ICameraSensor, ISensor

An implementation of T:Protogame.ICameraSensor which provides no cameras.

readonly Texture2D VideoCaptureFrame

readonly System.Byte[] VideoCaptureUnlockedRGBA

readonly System.Nullable<Int32> VideoCaptureWidth

readonly System.Nullable<Int32> VideoCaptureHeight

ICamera ActiveCamera

public void Render(IGameContext gameContext, IRenderContext renderContext)

Parameters:

• gameContext (Protogame.IGameContext) –
• renderContext (Protogame.IRenderContext) –

public void Update(IGameContext gameContext, IUpdateContext updateContext)

Parameters:

• gameContext (Protogame.IGameContext) –
• updateContext (Protogame.IUpdateContext) –

public System.Collections.Generic.List<ICamera> GetAvailableCameras()

SensorEngineHook

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the IEngineHook service via dependency injection to access this functionality.

Information documented here may not be up to date.

class SensorEngineHook : System.Object, IEngineHook

The default implementation of T:Protogame.IEngineHook.

public void Render(IGameContext gameContext, IRenderContext renderContext)

Parameters:

• gameContext (Protogame.IGameContext) –
• renderContext (Protogame.IRenderContext) –

public void Update(IGameContext gameContext, IUpdateContext updateContext)

Parameters:

• gameContext (Protogame.IGameContext) –
• updateContext (Protogame.IUpdateContext) –

public void Update(Protogame.IServerContext serverContext, IUpdateContext updateContext)

Parameters:

• serverContext (Protogame.IServerContext) –
• updateContext (Protogame.IUpdateContext) –

CoreServer<TInitialServerWorld, TServerWorldManager>

Warning

This documentation is for an implementation of a service. This class is not meant to be used directly; instead use the Protogame.CoreServer{TInitialServerWorld} service via dependency injection to access this functionality.

Information documented here may not be up to date.

class CoreServer<TInitialServerWorld, TServerWorldManager> : Protogame.Server, Protogame.ICoreServer, System.IDisposable

The implementation of Protogame’s base server class. In previous versions of Protogame, this acted as the base class for the developer’s Game class. However newer games written in Protogame should use T:Protogame.CoreServer`1 instead, as this correctly sets games to use the default server world manager, which sets TWorldManager to be T:Protogame.DefaultServerWorldManager automatically.

Type Parameters:  

• TInitialServerWorld – The initial server world class to start the server with.
• TServerWorldManager – The server world manager class for this game.

readonly Protogame.IServerContext ServerContext

readonly IUpdateContext UpdateContext

readonly bool Running

public void Dispose()

public void Stop()

public void Run()

public void Setup()