public enum GeometricPrimitiveType
{
Cube,
Sphere,
Cylinder,
Torus,
Teapot
}
If you look in the downloaded version of the engine you'll notice a 6th primitive shape called a BezierPrimitive. This isn't used directly, it is used by the TeapotPrimitive.using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
namespace SimpleGameEngine.Render
{
///
/// Custom vertex type for vertices that have just a
/// position and a normal, without any texture coordinates.
///
public struct VertexPositionNormal : IVertexType
{
public Vector3 Position;
public Vector3 Normal;
///
/// Constructor.
///
public VertexPositionNormal(Vector3 position, Vector3 normal)
{
Position = position;
Normal = normal;
}
///
/// A VertexDeclaration object, which contains information about the vertex
/// elements contained within this struct.
///
public static readonly VertexDeclaration VertexDeclaration = new VertexDeclaration
(
new VertexElement(0, VertexElementFormat.Vector3, VertexElementUsage.Position, 0),
new VertexElement(12, VertexElementFormat.Vector3, VertexElementUsage.Normal, 0)
);
VertexDeclaration IVertexType.VertexDeclaration
{
get { return VertexPositionNormal.VertexDeclaration; }
}
}
}
using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using SimpleGameEngine.GeometricPrimitives;
namespace SimpleGameEngine.Render
{
public class RenderDescription
{
// A render description must contain either a Model, or
// a GeometricPrimitive
public Model model;
public GeometricPrimitive geoPrim;
public Matrix worldTransform = Matrix.Identity;
public RenderDescription()
{
}
}
}
using System;
using System.Collections.Generic;
using System.Text;
namespace SimpleGameEngine
{
public class EngineCommon
{
public const String RootEntityName = "Root";
}
}
BaseEntity testCube2 = new BaseEntity(this, "Cube2"); testCube2.position = new Vector3(0, -1.01f, -10); RenderComponent rendComp2 = new RenderComponent(testCube2, GeometricPrimitiveType.Cube); AddEntityToScene(testCube2); BaseEntity testCube3 = new BaseEntity(this, "Cube3"); testCube3.position = new Vector3(0, 1.01f, -10); RenderComponent rendComp3 = new RenderComponent(testCube3, GeometricPrimitiveType.Cube); AddEntityToScene(testCube3);
public class RenderComponent : BaseComponent
private RenderDescription description; private Matrix scaleMatrix = Matrix.Identity;Notice we don't have accessors for these. The only time you want an accessor in a component is for data you want other users to be able to access or alter from outside the component. But if we make a script component giving access to these variables is as easy as making an accessor or function.
protected override String GetName()
{
return "Render";
}
public RenderComponent(BaseEntity ParentEntity, String ModelName) :
base(ParentEntity)
{
Initialize();
LoadModel(ModelName);
}
public RenderComponent(BaseEntity ParentEntity, GeometricPrimitiveType primitiveType) :
base(ParentEntity)
{
Initialize();
LoadPrimitive(primitiveType);
}
Notice the component pass the 'ParentEntity' reference to the base class, which is BaseComponent. BaseComponent stores that reference, and when the derived component calls base.Initilize(), within its own Initialize() method, then BaseComponent attaches the component to the Entity. private void LoadModel(String modelName)
{
description.model = this.Parent.Manager.Content.Load<model>(modelName);
}
private void LoadPrimitive(GeometricPrimitiveType primitiveType)
{
switch (primitiveType)
{
case GeometricPrimitiveType.Cube:
description.geoPrim = new CubePrimitive(this.Parent.Manager.Game.GraphicsDevice);
break;
case GeometricPrimitiveType.Sphere:
description.geoPrim = new SpherePrimitive(this.Parent.Manager.Game.GraphicsDevice);
break;
case GeometricPrimitiveType.Cylinder:
description.geoPrim = new CylinderPrimitive(this.Parent.Manager.Game.GraphicsDevice);
break;
case GeometricPrimitiveType.Torus:
description.geoPrim = new TorusPrimitive(this.Parent.Manager.Game.GraphicsDevice);
break;
case GeometricPrimitiveType.Teapot:
description.geoPrim = new TeapotPrimitive(this.Parent.Manager.Game.GraphicsDevice);
break;
default:
throw new Exception("LoadPrimitive does not handle this type of GeometricPrimitive. Was a new primitive type made and not handled here?");
}
}
Within LoadModel we utilitize the ContentManager to load our asset based on its name. ContentManager can be access from a component by going through the Entity, then SceneManager. And within LoadPrimitive we use an enum of a primitive type to decide which primitive to load. I will go over the GeometricPrimitives briefly in Part 5, there will be no need to go into them in full detail, as I didn't write them, they are extracted from a Microsoft XNA Sample that you can use if you wish to learn about them.public override void Update(GameTime gameTime)
{
description.worldTransform = this.scaleMatrix * this.Parent.rotation * Matrix.CreateTranslation(this.Parent.position);
}
public override void Draw(GameTime gameTime, ListrenderDescriptions) { // Could do frustum culling here if we wanted to be more efficient. // We could go a step further and gather the entities within sections of an octree that are // currently within the view frustum, then skip the frustum check here. renderDescriptions.Add(description); }
using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using SimpleGameEngine.Entity;
using SimpleGameEngine.Render;
using SimpleGameEngine.GeometricPrimitives;
namespace SimpleGameEngine.Components
{
public class RenderComponent : BaseComponent
{
private RenderDescription description;
private Matrix scaleMatrix = Matrix.Identity;
protected override String GetName()
{
return "Render";
}
public RenderComponent(BaseEntity ParentEntity, String ModelName) :
base(ParentEntity)
{
Initialize();
LoadModel(ModelName);
}
public RenderComponent(BaseEntity ParentEntity, GeometricPrimitiveType primitiveType) :
base(ParentEntity)
{
Initialize();
LoadPrimitive(primitiveType);
}
protected override void Initialize()
{
description = new RenderDescription();
description.worldTransform = this.scaleMatrix * this.Parent.rotation * Matrix.CreateTranslation(this.Parent.position);
base.Initialize();
}
private void LoadModel(String modelName)
{
description.model = this.Parent.Manager.Content.Load<Model>(modelName);
}
private void LoadPrimitive(GeometricPrimitiveType primitiveType)
{
switch (primitiveType)
{
case GeometricPrimitiveType.Cube:
description.geoPrim = new CubePrimitive(this.Parent.Manager.Game.GraphicsDevice);
break;
case GeometricPrimitiveType.Sphere:
description.geoPrim = new SpherePrimitive(this.Parent.Manager.Game.GraphicsDevice);
break;
case GeometricPrimitiveType.Cylinder:
description.geoPrim = new CylinderPrimitive(this.Parent.Manager.Game.GraphicsDevice);
break;
case GeometricPrimitiveType.Torus:
description.geoPrim = new TorusPrimitive(this.Parent.Manager.Game.GraphicsDevice);
break;
case GeometricPrimitiveType.Teapot:
description.geoPrim = new TeapotPrimitive(this.Parent.Manager.Game.GraphicsDevice);
break;
default:
throw new Exception("LoadPrimitive does not handle this type of GeometricPrimitive. Was a new primitive type made and not handled here?");
}
}
public override void Update(GameTime gameTime)
{
description.worldTransform = this.scaleMatrix * this.Parent.rotation * Matrix.CreateTranslation(this.Parent.position);
}
public override void Draw(GameTime gameTime, List<RenderDescription> renderDescriptions)
{
// Could do frustum culling here if we wanted to be more efficient.
// We could go a step further and gather the entities within sections of an octree that are
// currently within the view frustum, then skip the frustum check here.
renderDescriptions.Add(description);
}
}
}
using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using SimpleGameEngine.Entity;
using SimpleGameEngine.Render;
namespace SimpleGameEngine.Components
{
public class CameraComponent : BaseComponent
{
private float aspectRatio;
public float AspectRatio
{
get { return aspectRatio; }
}
protected override String GetName()
{
return "Camera";
}
public CameraComponent(BaseEntity ParentEntity) :
base(ParentEntity)
{
Initialize();
}
protected override void Initialize()
{
// Default aspect ratio is that of the viewport/window
aspectRatio = this.Parent.Manager.Game.GraphicsDevice.Viewport.AspectRatio;
base.Initialize();
}
}
}
private SceneManager manager;
public SceneManager Manager
{
get { return manager; }
}
private String name;
public String Name
{
get { return name; }
}
private Dictionary<String, BaseComponent> components;
public void AddComponent(BaseComponent component)
{
BaseComponent checkComponent = null;
if (components.TryGetValue(component.Name, out checkComponent))
{
throw new Exception("Component type " + component.Name + " already exists on this object: " + name);
}
components.Add(component.Name, component);
}
public void RemoveComponent(BaseComponent component)
{
BaseComponent checkComponent = null;
if (!components.TryGetValue(component.Name, out checkComponent))
{
throw new Exception("Component type " + component.Name + " doesn't exists on this object: " + name);
}
components.Remove(component.Name);
}
public BaseComponent GetComponent(String componentName)
{
BaseComponent component = null;
if (!components.TryGetValue(componentName, out component))
{
// Component wasn't found
}
return component;
}
public void Update(GameTime gameTime)
{
foreach (KeyValuePair<String, BaseComponent> pair in components)
{
(pair.Value).Update(gameTime);
}
}
public void Draw(GameTime gameTime, List<RenderDescription> renderDescriptions)
{
foreach ( KeyValuePair<String, BaseComponent> pair in components )
{
(pair.Value).Draw(gameTime, renderDescriptions);
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using SimpleGameEngine.Scene;
using SimpleGameEngine.Components;
using SimpleGameEngine.Render;
namespace SimpleGameEngine.Entity
{
public class BaseEntity
{
private SceneManager manager;
public SceneManager Manager
{
get { return manager; }
}
private String name;
public String Name
{
get { return name; }
}
private Dictionary<string, basecomponent> components;
// Public for performance reasons, accessors cause copies
public Vector3 position = Vector3.Zero;
public Matrix rotation = Matrix.Identity;
public BaseEntity(SceneManager sceneManager, String EntityName)
{
this.components = new Dictionary<string, basecomponent>();
this.manager = sceneManager;
this.name = EntityName;
}
public void AddComponent(BaseComponent component)
{
BaseComponent checkComponent = null;
if (components.TryGetValue(component.Name, out checkComponent))
{
throw new Exception("Component type " + component.Name + " already exists on this object: " + name);
}
components.Add(component.Name, component);
}
public void RemoveComponent(BaseComponent component)
{
BaseComponent checkComponent = null;
if (!components.TryGetValue(component.Name, out checkComponent))
{
throw new Exception("Component type " + component.Name + " doesn't exists on this object: " + name);
}
components.Remove(component.Name);
}
public BaseComponent GetComponent(String componentName)
{
BaseComponent component = null;
if (!components.TryGetValue(componentName, out component))
{
// Component wasn't found
}
return component;
}
public void Update(GameTime gameTime)
{
foreach (KeyValuePair<string, basecomponent> pair in components)
{
(pair.Value).Update(gameTime);
}
}
public void Draw(GameTime gameTime, List renderDescriptions)
{
foreach ( KeyValuePair<string, basecomponent> pair in components )
{
(pair.Value).Draw(gameTime, renderDescriptions);
}
}
}
}
private BaseEntity parent;
public BaseEntity Parent
{
get { return parent; }
}
public BaseComponent(BaseEntity parentEntity)
{
this.parent = parentEntity;
}
public String Name
{
get { return this.GetName(); }
}
// Name of the component
protected abstract String GetName();
protected virtual void Initialize()
{
this.parent.AddComponent(this);
}
public virtual void Update(GameTime gameTime) {}
public virtual void Draw(GameTime gameTime, List renderDescriptions) {}
using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using SimpleGameEngine.Entity;
using SimpleGameEngine.Render;
namespace SimpleGameEngine.Components
{
abstract public class BaseComponent
{
private BaseEntity parent;
public BaseEntity Parent
{
get { return parent; }
}
public String Name
{
get { return this.GetName(); }
}
public BaseComponent(BaseEntity parentEntity)
{
this.parent = parentEntity;
}
// Name of the component
protected abstract String GetName();
protected virtual void Initialize()
{
this.parent.AddComponent(this);
}
public virtual void Update(GameTime gameTime) {}
public virtual void Draw(GameTime gameTime, List<renderdescription> renderDescriptions) {}
}
}
private GraphicsDeviceManager graphics;
public GraphicsDeviceManager Graphics
{
get { return this.graphics; }
set { this.graphics = value; }
}
private Dictionary<String, BaseManager> managers;
public Dictionary<String, BaseManager> Managers
{
get { return this.managers; }
}
public MainGame()
{
this.graphics = new GraphicsDeviceManager(this);
this.Content.RootDirectory = "Content";
this.managers = new Dictionary<string, BaseManager>();
}
protected override void Initialize()
{
SceneManager sceneManager = new SceneManager(this);
RenderManager renderManager = new RenderManager(this);
base.Initialize();
}
public void AddManager(BaseManager manager)
{
BaseManager checkManager = null;
if (managers.TryGetValue(manager.Name, out checkManager))
{
throw new Exception("Manager type " + manager.Name + " already exists within the game engine");
}
managers.Add(manager.Name, manager);
}
We do a check to see if a Manager by the same name has already been registered with MainGame. This shouldn't happen, but better safe than sorry. Efficiency shouldn't be a problem here anyway, this method is only called a few times each time your game runs. The methods you really look at for optimization should be called either many times per frame, or are very time consuming methods.public BaseManager GetManager(String managerName)
{
BaseManager manager = null;
if (!managers.TryGetValue(managerName, out manager))
{
// Manager wasn't found
}
return manager;
}
protected override void LoadContent()
{
foreach (KeyValuePair<String, BaseManager> pair in managers)
{
(pair.Value).LoadContent();
}
}
protected override void UnloadContent()
{
foreach (KeyValuePair<String, BaseManager> pair in managers)
{
(pair.Value).UnloadContent();
}
}
protected override void Update(GameTime gameTime)
{
foreach (KeyValuePair<String, BaseManager> pair in managers)
{
(pair.Value).Update(gameTime);
}
}
protected override void Draw(GameTime gameTime)
{
foreach (KeyValuePair<String, BaseManager> pair in managers)
{
(pair.Value).Draw(gameTime);
}
base.Draw(gameTime);
}
You must register all Managers during MainGame's Initialize, because otherwise you will never get the call to LoadContent, because as you can see if only sends it to Managers that are registered.using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;
using SimpleGameEngine.Scene;
using SimpleGameEngine.Render;
namespace SimpleGameEngine
{
///
/// This is the main type for your game
///
public class MainGame : Microsoft.Xna.Framework.Game
{
private GraphicsDeviceManager graphics;
public GraphicsDeviceManager Graphics
{
get { return this.graphics; }
set { this.graphics = value; }
}
private Dictionary<String, BaseManager> managers;
public Dictionary<String, BaseManager> Managers
{
get { return this.managers; }
}
public MainGame()
{
this.graphics = new GraphicsDeviceManager(this);
this.Content.RootDirectory = "Content";
this.managers = new Dictionary<string, BaseManager>();
}
protected override void Initialize()
{
SceneManager sceneManager = new SceneManager(this);
RenderManager renderManager = new RenderManager(this);
base.Initialize();
}
public void AddManager(BaseManager manager)
{
BaseManager checkManager = null;
if (managers.TryGetValue(manager.Name, out checkManager))
{
throw new Exception("Manager type " + manager.Name + " already exists within the game engine");
}
managers.Add(manager.Name, manager);
}
public BaseManager GetManager(String managerName)
{
BaseManager manager = null;
if (!managers.TryGetValue(managerName, out manager))
{
// Manager wasn't found
}
return manager;
}
protected override void LoadContent()
{
foreach (KeyValuePair<String, BaseManager> pair in managers)
{
(pair.Value).LoadContent();
}
}
protected override void UnloadContent()
{
foreach (KeyValuePair<String, BaseManager> pair in managers)
{
(pair.Value).UnloadContent();
}
}
protected override void Update(GameTime gameTime)
{
foreach (KeyValuePair<String, BaseManager> pair in managers)
{
(pair.Value).Update(gameTime);
}
}
protected override void Draw(GameTime gameTime)
{
foreach (KeyValuePair<String, BaseManager> pair in managers)
{
(pair.Value).Draw(gameTime);
}
base.Draw(gameTime);
}
}
}
private Dictionary<String, BaseEntity> entities;
public Dictionary<String, BaseEntity> Entities
{
get { return entities; }
}
public ContentManager Content
{
get { return Game.Content; }
}
protected override String GetName()
{
return "Scene";
}
public SceneManager(MainGame Game)
: base(Game)
{
this.entities = new Dictionary();
Initialize();
}
protected override void Initialize()
{
base.Initialize();
}
public override void LoadContent()
{
// We always have at least one entity in the world. We'll create that now and then
// make it our main camera for the game.
BaseEntity entity = new BaseEntity(this, EngineCommon.RootEntityName);
// The component will automatically attach to the entity that we pass into it
CameraComponent camComp = new CameraComponent(entity);
// Now we add the entity to the scene
AddEntityToScene(entity);
// ===================================================================================
// TEMPORARY!!!!!!!!!!!!!!!!!!!!!!!!!!
BaseEntity testCube = new BaseEntity(this, "Cube");
testCube.position = new Vector3(0, 0, -10);
RenderComponent rendComp = new RenderComponent(testCube, GeometricPrimitiveType.Cube);
AddEntityToScene(testCube);
// ===================================================================================
}
There's a lot going on here, lets run down exactly what is happening.public override void Update(GameTime gameTime)
{
foreach (KeyValuePair<string, baseentity&rt; pair in entities)
{
(pair.Value).Update(gameTime);
}
}
public void AddEntityToScene(BaseEntity entity)
{
BaseEntity checkEntity = null;
if (entities.TryGetValue(entity.Name, out checkEntity))
{
throw new Exception("An entity named " + entity.Name + " already exists.");
}
entities.Add(entity.Name, entity);
}
public void RemoveEntityFromScene(BaseEntity entity)
{
BaseEntity checkEntity = null;
if (!entities.TryGetValue(entity.Name, out checkEntity))
{
throw new Exception("No entity named " + entity.Name + " exist in the scene to be removed.");
}
entities.Remove(entity.Name);
}
public BaseEntity GetEntity(String entityName)
{
BaseEntity entity = null;
if (!entities.TryGetValue(entityName, out entity))
{
// Entity wasn't found
}
return entity;
}
And you can see we've added a RemoveEntityFromScene method. We aren't using it yet, but it will remove the entity from the scene, but not delete the entity. If we were to multithread this engine (and maybe we will) and we wanted to add/remove component from it after it was loaded, we would make sure to lock the entity list, then remove the entity from the list, unlock the list, lock the entity, add/remove the necessary components, unlock the entity, lock the entity list, readd the entity to the list, unlock the list. Yea...fun stuff. Long story short we would need a method to remove the entity while it was having its components altered, or some other way to lock it, removing it might not be ideal because it could blip out of view.using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using SimpleGameEngine.Entity;
using SimpleGameEngine.Components;
using SimpleGameEngine.GeometricPrimitives;
namespace SimpleGameEngine.Scene
{
public class SceneManager : BaseManager
{
private Dictionary<String, BaseEntity> entities;
public Dictionary<String, BaseEntity> Entities
{
get { return entities; }
}
public ContentManager Content
{
get { return Game.Content; }
}
protected override String GetName()
{
return "Scene";
}
public SceneManager(MainGame Game)
: base(Game)
{
this.entities = new Dictionary<string, BaseEntity>();
Initialize();
}
protected override void Initialize()
{
base.Initialize();
}
public override void LoadContent()
{
// We always have at least one entity in the world. We'll create that now and then
// make it our main camera for the game.
BaseEntity entity = new BaseEntity(this, EngineCommon.RootEntityName);
// The component will automatically attach to the entity that we pass into it
CameraComponent camComp = new CameraComponent(entity);
// Now we add the entity to the scene
AddEntityToScene(entity);
// ===================================================================================
// TEMPORARY!!!!!!!!!!!!!!!!!!!!!!!!!!
BaseEntity testCube = new BaseEntity(this, "Cube");
testCube.position = new Vector3(0, 0, -10);
RenderComponent rendComp = new RenderComponent(testCube, GeometricPrimitiveType.Cube);
AddEntityToScene(testCube);
// ===================================================================================
}
public override void Update(GameTime gameTime)
{
foreach (KeyValuePair<String, BaseEntity> pair in entities)
{
(pair.Value).Update(gameTime);
}
}
public void AddEntityToScene(BaseEntity entity)
{
BaseEntity checkEntity = null;
if (entities.TryGetValue(entity.Name, out checkEntity))
{
throw new Exception("An entity named " + entity.Name + " already exists.");
}
entities.Add(entity.Name, entity);
}
public void RemoveEntityFromScene(BaseEntity entity)
{
BaseEntity checkEntity = null;
if (!entities.TryGetValue(entity.Name, out checkEntity))
{
throw new Exception("No entity named " + entity.Name + " exist in the scene to be removed.");
}
entities.Remove(entity.Name);
}
public BaseEntity GetEntity(String entityName)
{
BaseEntity entity = null;
if (!entities.TryGetValue(entityName, out entity))
{
// Entity wasn't found
}
return entity;
}
}
}
Create a Windows XNA project (this engine may or may not work for the Xbox 360 as well, I do not currently have a subscription to test it). I named mine 'SimpleGameEngine'. I then changed the name of the main project to 'GameEngine', and the name of the content project 'EngineContent'. Name yours whatever you would like, but I will refer to them from here on by these names. Additionally I named my Xna.Game class MainGame and changed the name of the file to Main.cs.private MainGame game;
public MainGame Game
{
get { return this.game; }
}
public String Name
{
get { return this.GetName(); }
}
Notice the accessor for 'name' calls a virtual function 'GetName()'. This is because the name of the manager is determined by the derived class, not this base class.// Name of the manager protected abstract String GetName();This is an abstract function so all derived classes must handle it.
public BaseManager(MainGame game)
{
this.game = game;
}
protected virtual void Initialize()
{
this.game.AddManager(this);
}
We make this protected so it cannot be called outside of a derived Manager class, and we make it virtual so that when it's called by the derived class it gives that class a chance to handle Initialization before calling the BaseManager.public virtual void LoadContent() {}
public virtual void UnloadContent() {}
public virtual void Update(GameTime gameTime) {}
public virtual void Draw(GameTime gameTime) {}
using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Xna.Framework;
namespace SimpleGameEngine
{
abstract public class BaseManager
{
private MainGame game;
public MainGame Game
{
get { return this.game; }
}
public String Name
{
get { return this.GetName(); }
}
public BaseManager(MainGame game)
{
this.game = game;
}
public virtual void LoadContent() {}
public virtual void UnloadContent() {}
public virtual void Update(GameTime gameTime) {}
public virtual void Draw(GameTime gameTime) {}
protected virtual void Initialize()
{
this.game.AddManager(this);
}
// Name of the manager
protected abstract String GetName();
}
}
public class RenderManager : BaseManager
protected override String GetName()
{
return "Render";
}
public RenderManager(MainGame game)
: base(game)
{
Initialize();
}
As I said in 'BaseManager', all Managers call Initialize() during construction. If you don't handle anything within this derived class during initialization then you don't technically need to create a function handler for it, but there's a good chance we'll need it eventually so let's just add it:protected override void Initialize()
{
base.Initialize();
}
public GraphicsDeviceManager Graphics
{
get { return this.Game.Graphics; }
set { this.Game.Graphics = value; }
}
public GraphicsDevice GraphicsDevice
{
get { return this.Game.GraphicsDevice; }
}
private SpriteBatch spriteBatch;
public SpriteBatch SpriteBatch
{
get { return spriteBatch; }
}
private BasicEffect effect;
private void LoadBasicEffect()
{
effect = new BasicEffect(this.GraphicsDevice);
effect.EnableDefaultLighting();
}
private String currentCameraEntityName = EngineCommon.RootEntityName;
public override void LoadContent()
{
LoadBasicEffect();
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(this.GraphicsDevice);
}
public override void Draw(GameTime gameTime)
{
SceneManager sceneMgr = this.Game.GetManager("Scene") as SceneManager;
if (null == sceneMgr)
{
throw new Exception("Scene manager not registered properly to the game engine");
}
BaseEntity cameraEntity = sceneMgr.GetEntity(currentCameraEntityName);
if (null == cameraEntity)
{
throw new Exception("A camera entity must always exist if we are trying to render a scene");
}
CameraComponent camComp = cameraEntity.GetComponent("Camera") as CameraComponent;
if (null == camComp)
{
throw new Exception("An entity was designated as a camera but never given a camera component");
}
this.GraphicsDevice.Clear(Color.CornflowerBlue);
List<renderdescription> renderDescriptions = new List<renderdescription>();
// Get all entities in the scene
Dictionary<string, baseentity> entities = sceneMgr.Entities;
foreach (KeyValuePair<string, baseentity> pair in entities)
{
(pair.Value).Draw(gameTime, renderDescriptions);
}
foreach (RenderDescription desc in renderDescriptions)
{
if (null != desc.model)
{
// Copy any parent transforms.
Matrix[] transforms = new Matrix[desc.model.Bones.Count];
desc.model.CopyAbsoluteBoneTransformsTo(transforms);
// Draw the model. A model can have multiple meshes, so loop.
foreach (ModelMesh mesh in desc.model.Meshes)
{
// This is where the mesh orientation is set, as well
// as our camera and projection.
foreach (BasicEffect effect in mesh.Effects)
{
effect.World = desc.worldTransform;
effect.View = Matrix.CreateLookAt(cameraEntity.position,
Vector3.Zero, Vector3.Up);
effect.Projection = Matrix.CreatePerspectiveFieldOfView(
MathHelper.ToRadians(45.0f), camComp.AspectRatio, 1.0f, 5000.0f);
}
// Draw the mesh, using the effects set above.
mesh.Draw();
}
}
else if (null != desc.geoPrim)
{
// Set our vertex declaration, vertex buffer, and index buffer.
this.Game.GraphicsDevice.SetVertexBuffer(desc.geoPrim.VertexBuffer);
this.Game.GraphicsDevice.Indices = desc.geoPrim.IndexBuffer;
foreach (EffectPass effectPass in effect.CurrentTechnique.Passes)
{
effect.World = desc.worldTransform;
effect.View = Matrix.CreateLookAt(cameraEntity.position,
(cameraEntity.position + cameraEntity.rotation.Forward), Vector3.Up);
effect.Projection = Matrix.CreatePerspectiveFieldOfView(
MathHelper.ToRadians(45.0f), camComp.AspectRatio, 1.0f, 5000.0f);
effectPass.Apply();
int primitiveCount = (desc.geoPrim.Indices.Count / 3);
this.Game.GraphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0,
desc.geoPrim.Vertices.Count, 0, primitiveCount);
}
}
}
}
using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using SimpleGameEngine.Scene;
using SimpleGameEngine.Entity;
using SimpleGameEngine.Components;
namespace SimpleGameEngine.Render
{
public class RenderManager : BaseManager
{
public GraphicsDeviceManager Graphics
{
get { return this.Game.Graphics; }
set { this.Game.Graphics = value; }
}
public GraphicsDevice GraphicsDevice
{
get { return this.Game.GraphicsDevice; }
}
private SpriteBatch spriteBatch;
public SpriteBatch SpriteBatch
{
get { return spriteBatch; }
}
private BasicEffect effect;
private String currentCameraEntityName = EngineCommon.RootEntityName;
protected override String GetName()
{
return "Render";
}
public RenderManager(MainGame game)
: base(game)
{
Initialize();
}
protected override void Initialize()
{
base.Initialize();
}
public override void LoadContent()
{
LoadBasicEffect();
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(this.GraphicsDevice);
}
private void LoadBasicEffect()
{
effect = new BasicEffect(this.GraphicsDevice);
effect.EnableDefaultLighting();
}
public override void Draw(GameTime gameTime)
{
SceneManager sceneMgr = this.Game.GetManager("Scene") as SceneManager;
if (null == sceneMgr)
{
throw new Exception("Scene manager not registered properly to the game engine");
}
BaseEntity cameraEntity = sceneMgr.GetEntity(currentCameraEntityName);
if (null == cameraEntity)
{
throw new Exception("A camera entity must always exist if we are trying to render a scene");
}
CameraComponent camComp = cameraEntity.GetComponent("Camera") as CameraComponent;
if (null == camComp)
{
throw new Exception("An entity was designated as a camera but never given a camera component");
}
this.GraphicsDevice.Clear(Color.CornflowerBlue);
List<renderdescription> renderDescriptions = new List<renderdescription>();
// Get all entities in the scene
Dictionary<string, baseentity> entities = sceneMgr.Entities;
foreach (KeyValuePair<string, baseentity> pair in entities)
{
(pair.Value).Draw(gameTime, renderDescriptions);
}
foreach (RenderDescription desc in renderDescriptions)
{
if (null != desc.model)
{
// Copy any parent transforms.
Matrix[] transforms = new Matrix[desc.model.Bones.Count];
desc.model.CopyAbsoluteBoneTransformsTo(transforms);
// Draw the model. A model can have multiple meshes, so loop.
foreach (ModelMesh mesh in desc.model.Meshes)
{
// This is where the mesh orientation is set, as well
// as our camera and projection.
foreach (BasicEffect effect in mesh.Effects)
{
effect.World = desc.worldTransform;
effect.View = Matrix.CreateLookAt(cameraEntity.position,
Vector3.Zero, Vector3.Up);
effect.Projection = Matrix.CreatePerspectiveFieldOfView(
MathHelper.ToRadians(45.0f), camComp.AspectRatio,
1.0f, 5000.0f);
}
// Draw the mesh, using the effects set above.
mesh.Draw();
}
}
else if (null != desc.geoPrim)
{
// Set our vertex declaration, vertex buffer, and index buffer.
this.Game.GraphicsDevice.SetVertexBuffer(desc.geoPrim.VertexBuffer);
this.Game.GraphicsDevice.Indices = desc.geoPrim.IndexBuffer;
foreach (EffectPass effectPass in effect.CurrentTechnique.Passes)
{
effect.World = desc.worldTransform;
effect.View = Matrix.CreateLookAt(cameraEntity.position,
(cameraEntity.position + cameraEntity.rotation.Forward), Vector3.Up);
effect.Projection = Matrix.CreatePerspectiveFieldOfView(
MathHelper.ToRadians(45.0f), camComp.AspectRatio,
1.0f, 5000.0f);
effectPass.Apply();
int primitiveCount = (desc.geoPrim.Indices.Count / 3);
this.Game.GraphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0,
desc.geoPrim.Vertices.Count, 0, primitiveCount);
}
}
}
}
}
}
#pragma once
#ifndef __PhysicsVisualDebugger_h_
#define __PhysicsVisualDebugger_h_
#include <common\visualize\hkvisualdebugger.h>
class PhysicsVisualDebugger : public hkVisualDebugger
{
public:
PhysicsVisualDebugger(const hkArray<hkProcessContext*>,
const class hkVtableClassRegistry* classReg = HK_NULL)
: hkVisualDebugger(contexts, classReg)
{}
virtual ~PhysicsVisualDebugger() {};
unsigned int GetNumClients() const { return m_clients.getSize(); }
};
#endif //__PhysicsVisualDebugger_h_
unsigned int numConnections = m_pDebugger->GetNumClients();
// Update the debuggers (which also checks for new clients)
m_pDebugger->step(m_fStepLength);
// If there are now more connections than before the update
if ( m_pDebugger->GetNumClients() > numConnections )
{
// This is where you will want to go through all physics
// objects and have to re-send their color info to the
// debugger.
UpdateDebuggerInfoForAllEntities();
}
float CalcTimeOverDistance( float initVelocity,
float constantAccel,
float distance )
{
if ( distance <= 0.0f )
{
return 0.0f;
}
// If there is an acceleration present
if ( constantAccel != 0.0f )
{
float initVelSqr = initVelocity * initVelocity;
return (-initVelocity
+ sqrt(initVelSqr + (2*constantAccel*distance))
/ constantAccel;
}
else // No acceleration was present
{
if ( initVelocity == 0.0f )
{
// No velocity or acceleration means infinite
// time required, just return 0.0f, or whatever
// value you want to return in this case.
return 0.0f;
}
else
{
return ( distance / initVelocity );
}
}
}
So now we can see that the platform will reach P2 in only 1.3455868 seconds, and because the client stuttered for 2 seconds that leaves us 0.6544132 seconds we need to predict. The next step is to see how much time it takes to get from P2 to P3, and if that is greater than 0.6544132 seconds than we need know we're not to P3 yet and we can calculate how far we've traveled between P2 and P3. 
float CalculateConstantAccel(const float initVelocity,
const float finalVelocity,
const float distance)
{
if ( distance <= 0.0f )
{
return 0.0f;
}
float finalVelocitySqr = finalVelocity * finalVelocity;
float initVelocitySqr = initVelocity * initVelocity;
return (finalVelocitySqr - initVelocitySqr)
/ (2 * distance);
}
float CalcDistanceOverTime(const float initVelocity,
const float constantAccel,
const float timeDelta)
{
return (initVelocity * timeDelta)
+ (0.5f * constantAccel * (timeDelta * timeDelta);
}