A graphics accelerator card suitable for gaming, this includes most mid-range to high-end cards purchased within the last two years. The following link has a list of graphics cards we have tried:

http://channel9.msdn.com/wiki/default.aspx/Channel9.SimulationFAQ

This tutorial is designed for use with Microsoft Visual C#. You can use:

• Microsoft Visual C# Express Edition
• Microsoft Visual Studio Standard, Professional, or Team Edition.

You will also need Microsoft Internet Explorer or another conventional web browser.

Define the SetupCamera method as follows:

 private void SetupCamera()
{
    // Set up initial view
    CameraView view = new CameraView();
    view.EyePosition = new Vector3(-1.65f, 1.63f, -0.29f);
    view.LookAtPoint = new Vector3(-0.68f, 1.38f, -0.18f);
    SimulationEngine.GlobalInstancePort.Update(view);
}

As you see, SetupCamera instantiates a new CameraView object, sets the proper position and orientation in the scene and posts it to the simulation engine as an Update message.

Begin by examining how you can add a sky to the physics world. In game terminology, this is called the sky box since it gives the illusion of a sky by using a "box" or hemi-sphere to wrap the visual world.

 void AddSky()
{
    // Add a sky using a static texture. We will use the sky texture
    // to do per pixel lighting on each simulation visual entity
    SkyDomeEntity sky = new SkyDomeEntity("skydome.dds", "sky_diff.dds");
    SimulationEngine.GlobalInstancePort.Insert(sky);

    // Add a directional light to simulate the sun.
    LightSourceEntity sun = new LightSourceEntity();
    sun.State.Name = "Sun";
    sun.Type = LightSourceEntityType.Directional;
    sun.Color = new Vector4(0.8f, 0.8f, 0.8f, 1);
    sun.Direction = new Vector3(0.5f, -.75f, 0.5f);
    SimulationEngine.GlobalInstancePort.Insert(sun);
}

The SkyEntity class takes two file names as parameters:

• A texture file used as the sky bitmap. Use high resolution images for detailed skies.
• A simplified version of the first texture in cube map form (cube maps are 6 textures, like a cube with its sides unfolded), which is used for per-pixel lighting effects.

The simulation engine produces high quality lighting effects by sampling the sky cube map texture and adding the light component to other light sources for each pixel being rendered in the world.

The LightEntity class is used to simulate light sources (explained in more detail in simulation tutorial 5), used here to simulate the sun in an outdoor scene.

Now let's examine how you can add a ground plane to the physics world. It's a good idea to add a ground before any other object; otherwise, assuming gravity is enabled, any other entity we add will fall to the virtual abyss.

 void AddGround()
{
    // create a large horizontal plane, at zero elevation.
    HeightFieldEntity ground = new HeightFieldEntity(
        "simple ground", // name
        "03RamieSc.dds", // texture image
        new MaterialProperties("ground",
            0.2f, // restitution
            0.5f, // dynamic friction
            0.5f) // static friction
        );
    SimulationEngine.GlobalInstancePort.Insert(ground);
}

A ground entity normally uses the HeightFieldEntity predefine, which expects an array of height samples. The example above uses a constructor that creates a flat plane, which is a common use of height fields. There are two things that are important to remember for almost all entities:

• You set the material properties specifying friction and restitution. The physics engine supports advanced friction models (anisotropic, special cased tire force functions for wheels) but in most cases, use static and dynamic friction coefficients.
• You add the entity to the simulation by calling the asynchronous Insert method on the simulation engine port (in turn, it posts the entity as an Insert message).

Next, add a simple entity (which has just a single shape). The geometry of the shape you add is used for both physics simulation and visualization. The simulation engine renders the physical shape by default if no detailed file mesh is supplied. This enables quick prototyping and does not affect the simulation fidelity unless you rely on advanced entities like simulated vision.

 void AddBox(Vector3 position)
{
    Vector3 dimensions =
        new Vector3(0.2f, 0.2f, 0.2f); // meters

    // create simple movable entity, with a single shape
    SingleShapeEntity box = new SingleShapeEntity(
        new BoxShape(
            new BoxShapeProperties(
            100, // mass in kilograms.
            new Pose(), // relative pose
            dimensions)), // dimensions
        position);

    // mass or density can be specified.  No need to specify both
    box.State.MassDensity.Mass = 0;

    // Name the entity. All entities must have unique names
    box.State.Name = "box";

    // Insert entity in simulation.
    SimulationEngine.GlobalInstancePort.Insert(box);
}

The pre-defined entity, SingleShapeEntity, is a good starting point for adding objects to the simulation world. It assumes the entity is described by a single shape. Based on that assumption, SingleShapeEntity takes care of rendering the object and adding it to the physics simulation. You must specify the shape properties using one of the pre-defined shapes or one that derives from the Shape class defined in SimulationCommon.dll.

Some things to pay particular attention to include:

• Shapes that have no mass or density specified will be static. They can not be moved and are assumed to have infinite mass.
• Shapes are used to describe the entity to the physics engine. Rendering is decoupled from the physics geometry if a file-based mesh is supplied. More on that later.
• The Pose class describes the position and orientation of an entity or shape. For shapes, it describes the relative position of the shape within an entity. Assume the entity center is (0,0,0) in entity coordinates, unless the center of mass parameter is set in the entity state.
• All entities must have a unique name. In these tutorials, names are not qualified to make them unique since the total number of entities being added is known. But in large-scale simulations, always ensure no name conflicts occur. Duplicates are not allowed because entity discovery is done by name.

The simulation engine makes it very easy to use detailed, photo-realistic visuals to represent entities in the world. All you have to supply is a file-based DirectX mesh file and (optionally) a pixel + vertex shader effect. You can supply a list of meshes for each physical shape in the entity. The engine takes care of rendering the meshes using the updated physics simulation properties for its shape (so the mesh will always be oriented and positioned properly). This makes it literally a "one line" for someone to start using nice visuals in the simulation. In the example below, a standard Directx9 mesh file is used and a 1.0 sphere is used to represent it to physics.

 void AddTexturedSphere(Vector3 position)
{
    SingleShapeEntity entity = new SingleShapeEntity(
        new SphereShape(
            new SphereShapeProperties(10, // mass in kg
            new Pose(), // pose of shape within entity
            1)), //default radius
        position);

    entity.State.Assets.Mesh = "earth.obj";
    entity.SphereShape.SphereState.Material = new MaterialProperties("sphereMaterial", 0.5f, 0.4f, 0.5f);

    // Name the entity
    entity.State.Name = "detailed sphere";

    // Insert entity in simulation.
    SimulationEngine.GlobalInstancePort.Insert(entity);
}

Key points to focus on when using entities with file based mesh files:

• All file paths specified in the Assets member of an entity state are assumed to reside in the store\Media directory. Only the filename is used, path will be ignored. This means you must copy all media, including textures referenced by the mesh file, to the store\Media directory.
• When using a mesh, you can use advanced entities such as the TriangleMeshEnvironmentEntity or SimplifiedConvexMeshEnvironmentEntity to properly calculate physics shapes. More details on this in upcoming tutorials. Alternately, you can use a collection of simple shapes to approximate a complex mesh.

• F1 - Hides help text.
• F2 - Toggles display/rendering of the physics primitive visualization. Useful for debugging your physics geometry.

• Camera Movement:

  • A - Strafe Left (lateral move left)
  • D - Strafe Right (lateral move right)
  • W - Move Forward
  • S - Move Backward
  • Q - Move Up on the Y-axis (vertically)
  • E - Move Down in the Y-axis (vertically)

Mouse Controls