public void Update(IXNAGame _game)
{
sphereMesh.Update(game);
if (game.Keyboard.IsKeyPressed(Microsoft.Xna.Framework.Input.Keys.F))
{
var pos = shooterCamera.ViewInverse.Translation;
var dir = Vector3.Transform(Vector3.Forward, shooterCamera.ViewInverse) - pos;
var iSphere = new ClientPhysicsTestSphere(engine.Scene,
pos + dir
, 0.3f);
iSphere.InitDynamic();
iSphere.Actor.LinearVelocity = dir * 10;
spheres.Add(iSphere);
}
for (int i = 0; i < spheres.Count; i++)
{
spheres[i].Update(root, game);
}
}
public void Update(IXNAGame _game)
{
if (updateTasks.Count == 0)
{
return;
}
float elapsedRemaining = _game.Elapsed;
while (elapsedRemaining > 0.001f && updateTasks.Count > 0)
{
Task task = updateTasks.Peek();
if (task.Duration > elapsedRemaining)
{
task.TaskDelegate(elapsedRemaining);
task.Duration -= elapsedRemaining;
break;
}
else
{
task.TaskDelegate(task.Duration);
elapsedRemaining -= task.Duration;
updateTasks.Dequeue();
}
}
}
/// <summary>
/// This calls the update function on a list of objects
/// TODO: these are not working at the moment
/// </summary>
/// <param name="objs"></param>
public static void Update(IXNAGame game, List <IXNAObject> objs)
{
for (int i = 0; i < objs.Count; i++)
{
objs[i].Update(game);
}
}
public static void temp(IXNAGame Game, Actor actor)
{
var mat = actor.CenterOfMassGlobalOrientation;
Game.LineManager3D.AddLine(actor.CenterOfMassGlobalPosition, actor.CenterOfMassGlobalPosition + mat.Forward, Color.LightGreen);
actor.AddTorque(mat.Forward * 10000, ForceMode.Force);
}
} // Load()
public static BasicShader LoadFromEmbeddedFile(IXNAGame game, Assembly assembly, string manifestResource, string sourceFileRelativePath, EffectPool pool)
{
var shader = new BasicShader(game);
shader.InitFromEmbeddedFile(game, assembly, manifestResource, sourceFileRelativePath, pool);
return(shader);
}
/// <summary>
/// This calls the update function on a list of objects
/// TODO: these are not working at the moment
/// </summary>
/// <param name="objs"></param>
public static void Render(IXNAGame game, List <IXNAObject> objs)
{
for (int i = 0; i < objs.Count; i++)
{
objs[i].Render(game);
}
}
public void Render(IXNAGame game)
{
if (!Enabled)
{
return;
}
}
public void Render(IXNAGame game)
{
shader.ViewProjection = game.Camera.ViewProjection;
game.GraphicsDevice.VertexDeclaration = vertexDeclaration;
shader.RenderPrimitiveSinglePass(primitives, SaveStateMode.None);
}
private void initializeDeferredShading(IXNAGame _game, int backBufferWidth, int backBufferHeight)
{
shadowMapRT = new RenderTarget2D(_game.GraphicsDevice, shadowMapSize,
shadowMapSize, 1, SurfaceFormat.Single);
shadowMapDS = new DepthStencilBuffer(GraphicsDevice,
shadowMapSize,
shadowMapSize,
GraphicsDevice.DepthStencilBuffer.Format);
lightRT = new RenderTarget2D(GraphicsDevice, backBufferWidth,
backBufferHeight, 1, SurfaceFormat.HalfVector4, RenderTargetUsage.PreserveContents);
deferredFinalRT = new RenderTarget2D(GraphicsDevice, backBufferWidth,
backBufferHeight, 1, SurfaceFormat.HalfVector4, RenderTargetUsage.PreserveContents);
directionalLightShader = loadShader("DirectionalLight.fx");
directionalLightShader.SetTechnique("Technique0");
finalCombineEffect = loadShader("CombineFinal.fx");
finalCombineEffect.SetTechnique("Technique1");
pointLightShader = loadShader("PointLight.fx");
pointLightShader.SetTechnique("Technique1");
spotLightShader = loadShader("SpotLight.fx");
spotLightShader.SetTechnique("Technique1");
shadowMapShader = loadShader("ShadowMap.fx");
}
public void RenderNodeBoundingBox <T>(IXNAGame game, IQuadTreeNode <T> quadTreeNode) where T : IQuadTreeNode <T>
{
if (quadTreeNode == null)
{
return;
}
QuadTreeNodeData <T> node = quadTreeNode.NodeData;
RenderNodeBoundingBox(game, node.UpperLeft);
RenderNodeBoundingBox(game, node.UpperRight);
RenderNodeBoundingBox(game, node.LowerLeft);
RenderNodeBoundingBox(game, node.LowerRight);
//TODO: Calculate level is quite lame here and slow, since we loop the tree level by level
int level = QuadTree.CalculateLevel(quadTreeNode);
Color col;
if (level < levelColors.Length)
{
col = levelColors[level];
}
else
{
col = levelColors[levelColors.Length - 1];
}
game.LineManager3D.AddBox(quadTreeNode.NodeData.BoundingBox.xna(), col);
}
public WorldObject CreateNewWorldObject(IXNAGame game, WorldObjectType objectType, SimpleMeshRenderer renderer)
{
var worldObject = new WorldObject(game, objectType, renderer);
addWorldObject(worldObject);
return(worldObject);
}
public void Update(ClientPhysicsQuadTreeNode root, IXNAGame game)
{
if (sleeping && actor.IsSleeping)
{
return;
}
if (sleeping && !actor.IsSleeping)
{
// Make dynamic again!
sleeping = false;
Node.AddDynamicObjectToIntersectingNodes(this);
}
if (actor.IsSleeping && !sleeping)
{
// Disable dynamic, thus make static
if (node != null)
{
node.RemoveDynamicObjectFromIntersectingNodes(this);
}
sleeping = true;
if (node != null && node.PhysicsEnabled == false)
{
DisablePhysics(); // disable movement
}
return;
}
Move(root, actor.GlobalPosition);
}
/// <summary>
/// This calls the update function on a list of objects
/// TODO: these are not working at the moment
/// </summary>
/// <param name="objs"></param>
public static void Initialize(IXNAGame game, List <IXNAObject> objs)
{
for (int i = 0; i < objs.Count; i++)
{
objs[i].Initialize(game);
}
}
/// <summary>
/// Load an effect from an hlsl .fx file
/// </summary>
public static BasicShader LoadFromFXFile(IXNAGame game, IGameFile file)
{
BasicShader shader = new BasicShader(game);
//obs?
// Dispose old shader
if (shader.effect != null)
{
shader.effect.Dispose();
shader.effect = null;
}
CompiledEffect compiledEffect;
try
{
compiledEffect = Effect.CompileEffectFromFile(file.GetFullFilename(), null, null, CompilerOptions.None, TargetPlatform.Windows);
shader.effect = new Effect(game.GraphicsDevice, compiledEffect.GetEffectCode(), CompilerOptions.None, null);
} // try
catch (Exception ex)
{
/*Log.Write( "Failed to load shader " + shaderContentName + ". " +
* "Error: " + ex.ToString() );*/
// Rethrow error, app can't continue!
throw ex;
}
shader.LoadParameters();
return(shader);
} // Load()
public void Render(IXNAGame _game)
{
for (int i = 0; i < spheres.Count; i++)
{
sphereMesh.WorldMatrix = Matrix.CreateTranslation(spheres[i].Center);
sphereMesh.Render(game);
}
}
public TWMouse(IXNAGame nGame)
{
game = nGame;
speed = 0.1f;
relativeX = 0;
relativeY = 0;
relativeScrollWheel = 0;
}
public void Update(IXNAGame _game)
{
foreach (var f in forms)
{
f.WriteDataContext();
f.ReadDataContext();
}
}
public void Initialize(IXNAGame _game)
{
VertexDeclaration = Renderer.GetVertexDeclaration <TangentVertex>();
effectPool = new EffectPool();
Shader = new DefaultModelShader(_game, effectPool);
}
} // Material(ambientColor, diffuseColor, setDiffuseTexture)
/// <summary>
/// Create material
/// </summary>
public Material(IXNAGame _game, string setDiffuseTexture, string setNormalTexture,
string setHeightTexture)
{
diffuseTexture = new TextureBookengine(_game, setDiffuseTexture);
normalTexture = new TextureBookengine(_game, setNormalTexture);
heightTexture = new TextureBookengine(_game, setHeightTexture);
// Leave rest to default
} // Material(ambientColor, diffuseColor, setDiffuseTexture)
} // Material(setDiffuseTexture)
/// <summary>
/// Create material
/// </summary>
public Material(IXNAGame _game, Color setAmbientColor, Color setDiffuseColor,
string setDiffuseTexture)
{
ambientColor = setAmbientColor;
diffuseColor = setDiffuseColor;
diffuseTexture = new TextureBookengine(_game, setDiffuseTexture);
// Leave rest to default
} // Material(ambientColor, diffuseColor, setDiffuseTexture)
/// <summary>
/// Load an effect from an hlsl .fx file
/// </summary>
public static BasicShader LoadFromFXFile(IXNAGame game, IGameFile file, EffectPool pool)
{
BasicShader s = new BasicShader(game);
s.LoadFromFXFile(file, pool);
return(s);
}
public static BasicShader LoadFromFXFile(IXNAGame game, System.IO.Stream strm, EffectPool pool)
{
BasicShader s = new BasicShader(game);
s.LoadFromFXFile(strm, pool);
return(s);
}
public TestSphereShooter(IXNAGame game, PhysicsEngine engine, ClientPhysicsQuadTreeNode root, ICamera shooterCamera)
{
this.game = game;
this.engine = engine;
this.root = root;
this.shooterCamera = shooterCamera;
sphereMesh = new SphereMesh(0.3f, 20, Color.Green);
}
public static SkinnedModel LoadSkinnedModel(IXNAGame game, Stream colladaStream)
{
ColladaModel colladaModel = ColladaModel.FromStream(colladaStream);
SkinnedModelBuilder builder = new SkinnedModelBuilder();
return(builder.CreateSkinnedModel(game, colladaModel));
}
public WorldObject(IXNAGame game, WorldObjectType objectType, SimpleMeshRenderer renderer)
{
this.game = game;
ObjectType = objectType;
Renderer = renderer;
renderElement = Renderer.AddMesh(ObjectType.Mesh);
updateWorldMatrix();
}
public void Initialize(IXNAGame _game)
{
for (int i = 0; i < renderables.Count; i++)
{
renderables[i].Initialize(game);
}
initialized = true;
}
public WorldSerializer(IMeshFactory meshFactory, DiskTileDataFactory diskTileDataFactory, IXNAGame game, SimpleMeshRenderer renderer, SimpleWorldObjectTypeFactory worldObjectTypeFactory, TileSnapInformationBuilder builder)
{
this.meshFactory = meshFactory;
this.diskTileDataFactory = diskTileDataFactory;
this.game = game;
this.renderer = renderer;
this.worldObjectTypeFactory = worldObjectTypeFactory;
this.builder = builder;
}
public CustomCamera(IXNAGame nGame)
{
game = nGame;
projection = Matrix.Identity;
view = Matrix.Identity;
viewInverse = Matrix.Identity;
viewProjection = Matrix.Identity;
nearClip = 1.0f;
farClip = 1000f;
}
public WorldObjectPlaceTool(IXNAGame _game, World _world, SimpleMeshRenderer _renderer, TileSnapInformationBuilder _builder, IMeshFactory meshFactory, ITileFaceTypeFactory tileFaceTypeFactory)
{
game = _game;
World = _world;
renderer = _renderer;
builder = _builder;
this.meshFactory = meshFactory;
this.tileFaceTypeFactory = tileFaceTypeFactory;
worldTileSnapper = new WorldTileSnapper(builder);
}
public static VertexDeclaration CreateVertexDeclaration(IXNAGame game)
{
VertexElement[] vertPos = new VertexElement[] {
new VertexElement(0, 0,
VertexElementFormat.Vector3,
VertexElementMethod.Default,
VertexElementUsage.Position,
0)
};
return(new VertexDeclaration(game.GraphicsDevice, vertPos));
}
