public void TestVertexDeclarationPool()
{
XNAGame game = new XNAGame();
game.DrawFps = true;
var pool = new VertexDeclarationPool();
pool.SetVertexElements <TangentVertex>(TangentVertex.VertexElements);
game.AddXNAObject(pool);
game.DrawEvent += delegate
{
var decl1 = pool.GetVertexDeclaration <TangentVertex>();
var decl2 = pool.GetVertexDeclaration <TangentVertex>();
Assert.NotNull(decl1);
Assert.AreEqual(decl1, decl2);
game.Exit();
};
game.Run();
}
private void setupWorldObjectTypes(XNAGame game, SimpleMeshRenderer renderer, TileSnapInformationBuilder builder)
{
OBJParser.ObjImporter importer = new OBJParser.ObjImporter();
var c = new OBJToRAMMeshConverter(new RAMTextureFactory());
importer.AddMaterialFileStream("WallInnerCorner.mtl", new FileStream(TWDir.GameData.CreateSubdirectory("Core\\TileEngine") + "/TileSet001/WallInnerCorner.mtl", FileMode.Open));
importer.ImportObjFile(TWDir.GameData.CreateSubdirectory("Core\\TileEngine") + "/TileSet001/WallInnerCorner.obj");
meshWallInnerCorner = c.CreateMesh(importer);
importer.AddMaterialFileStream("WallStraight.mtl", new FileStream(TWDir.GameData.CreateSubdirectory("Core\\TileEngine") + "/TileSet001/WallStraight.mtl", FileMode.Open));
importer.ImportObjFile(TWDir.GameData.CreateSubdirectory("Core\\TileEngine") + "/TileSet001/WallStraight.obj");
meshWallStraight = c.CreateMesh(importer);
wallInnerCornerType = new WorldObjectType(meshWallInnerCorner, Guid.NewGuid(), builder);
wallStraightType = new WorldObjectType(meshWallStraight, Guid.NewGuid(), builder);
var tileDataInnerCorner = new TileData(Guid.NewGuid());
var tileDataStraight = new TileData(Guid.NewGuid());
tileDataInnerCorner.Dimensions = wallInnerCornerType.BoundingBox.Max - wallInnerCornerType.BoundingBox.Min;
tileDataInnerCorner.MeshOffset = Matrix.CreateTranslation(new Vector3(0, 0, 0));
tileDataStraight.Dimensions = wallStraightType.BoundingBox.Max - wallStraightType.BoundingBox.Min;
tileDataStraight.MeshOffset = Matrix.CreateTranslation(new Vector3(0, 0, 0));
wallInnerCornerType.TileData = tileDataInnerCorner;
wallStraightType.TileData = tileDataStraight;
typeList.Add(wallInnerCornerType);
typeList.Add(wallStraightType);
}
public CogEngine(XNAGame game, PhysicsEngine engine)
{
Game = game;
Engine = engine;
raycastReport = new CogRaycastReport(this);
}
public void TestQuadtreeSplitMerge()
{
TestQuadTreeNode root = new TestQuadTreeNode();
root.NodeData = new QuadTreeNodeData <TestQuadTreeNode>(
new BoundingBox(new Vector3(-100, -5, -100), new Vector3(100, 5, 100)).dx()
);
QuadTree.Split(root, 4);
QuadTree.Merge(root.NodeData.LowerRight.NodeData.LowerRight.NodeData.UpperLeft);
QuadTree.MergeRecursive(root.NodeData.LowerLeft.NodeData.UpperRight);
QuadTree.MergeRecursive(root.NodeData.UpperRight);
QuadTreeVisualizerXNA visualizer = new QuadTreeVisualizerXNA();
XNAGame game = new XNAGame();
game.DrawEvent +=
delegate
{
visualizer.RenderNodeGroundBoundig(game, root);
visualizer.RenderNodeBoundingBox(game, root);
};
game.Run();
}
public void TestFollowCurve()
{
XNAGame game = new XNAGame();
Curve3D curve = Curve3D.CreateTestCurve();
game.SpectaterCamera.CameraDirection = Vector3.Normalize(new Vector3(-0.2f, -1f, -0.4f));
BoundingSphere sphere = curve.CalculateBoundingSphere();
sphere.Radius += 1.5f;
game.SpectaterCamera.FitInView(sphere);
float time = 0;
game.DrawEvent +=
delegate
{
if (game.Keyboard.IsKeyPressed(Keys.V))
{
game.SpectaterCamera.CameraDirection = Vector3.Normalize(new Vector3(-0.2f, -1f, -0.4f));
}
Render(curve, game, Color.Red);
game.LineManager3D.AddCenteredBox(curve.Evaluate(time), 0.2f, Color.Green);
time += game.Elapsed;
};
game.Run();
}
public void TestPhysicsDebugRendererXNA()
{
XNAGame game = new XNAGame();
game.SpectaterCamera.CameraPosition = new Vector3(0, 0, -40);
PhysicsEngine engine = new PhysicsEngine();
//game.AddXNAObject(engine);
engine.Initialize();
PhysicsDebugRendererXNA debugRenderer = new PhysicsDebugRendererXNA(game, engine.Scene);
game.AddXNAObject(debugRenderer);
game.AddXNAObject(engine);
InitTestScene(engine.Scene);
/*game.InitializeEvent += delegate
* {
*
*
*
* };
*
* game.UpdateEvent += delegate
* {
* engine.Update(game.Elapsed);
* };*/
game.Run();
engine.Dispose();
}
public void TestBasicShaderAutoReload()
{
BasicShader shader = null;
FullScreenQuad quad = null;
XNAGame game = new XNAGame();
game.InitializeEvent += delegate
{
shader = BasicShader.LoadFromEmbeddedFile(game,
typeof(GraphicsTest).Assembly, "MHGameWork.TheWizards.Tests.Graphics.Files.TestShader.fx",
"..\\..\\Unit Tests\\Graphics\\Files\\TestShader.fx",
new EffectPool());
shader.SetTechnique("Technique1");
quad = new FullScreenQuad(game.GraphicsDevice);
};
game.DrawEvent += delegate
{
shader.RenderMultipass(delegate
{
quad.DrawOld(game.GraphicsDevice);
});
};
game.Run();
}
public static void TestEditorMeshPartRenderDataSimple()
{
XNAGame game = new XNAGame();
ColladaShader shader = null;
game.InitializeEvent +=
delegate
{
TreeStructure struc;
TreeEngine.EngineTreeRenderDataGenerater gen = new TreeEngine.EngineTreeRenderDataGenerater(20);
struc = TreeStructure.GetTestTreeStructure(game);
TreeEngine.EngineTreeRenderData renderData = gen.GetRenderData(struc, game, 0);
//List<TangentVertex> vertices = new List<TangentVertex>();
//vertices.Add(new TangentVertex(new Vector3(-1, 2.5f, 0), new Vector2(0, 0), new Vector3(0, 0, 1), new Vector3(1, 0, 0)));
//vertices.Add(new TangentVertex(new Vector3(-1, 0, 0), new Vector2(0, 1), new Vector3(0, 0, 1), new Vector3(1, 0, 0)));
//vertices.Add(new TangentVertex(new Vector3(1, 0, 0), new Vector2(1, 1), new Vector3(0, 0, 1), new Vector3(1, 0, 0)));
//vertices.Add(new TangentVertex(new Vector3(-1, 2.5f, 0), new Vector2(0, 0), new Vector3(0, 0, 1), new Vector3(1, 0, 0)));
//vertices.Add(new TangentVertex(new Vector3(1, 2.5f, 0), new Vector2(1, 0), new Vector3(0, 0, 1), new Vector3(1, 0, 0)));
//vertices.Add(new TangentVertex(new Vector3(1, 0, 0), new Vector2(1, 1), new Vector3(0, 0, 1), new Vector3(1, 0, 0)));
ObjExporter exp = new ObjExporter();
exp.ExportToObj("testExportNoFlipNormals.obj", renderData);
};
game.Run();
}
public void TestLoadTexture()
{
XNAGame game = new XNAGame();
TexturePool pool = new TexturePool();
game.AddXNAObject(pool);
game.DrawFps = true;
RAMTexture tex = DefaultMeshes.GetTestTexture();
game.DrawEvent += delegate
{
//We should do this ACTUALLY in real usage situations, but it proves we cache the data.
game.SpriteBatch.Begin();
int row = 0;
int col = 0;
int width = 10;
for (int i = 0; i < 100; i++)
{
row = i / width;
col = i % width;
game.SpriteBatch.Draw(pool.LoadTexture(tex), new Rectangle(10 + col * 40, 10 + row * 40, 40, 40), Color.White);
}
game.SpriteBatch.End();
};
game.Run();
}
public void TestRenderBoxMesh()
{
XNAGame game;
BoxMesh mesh = null;
game = new XNAGame();
game.InitializeEvent +=
delegate
{
mesh = new BoxMesh();
mesh.Initialize(game);
};
game.DrawEvent +=
delegate
{
game.LineManager3D.AddAABB(mesh.BoundingBox, Matrix.Identity, Color.Red);
if (game.Keyboard.IsKeyPressed(Microsoft.Xna.Framework.Input.Keys.R))
{
mesh.ReloadShader(game);
}
mesh.Render(game);
};
game.Run();
}
public void TestBasicShaderCustomInclude()
{
BasicShader shader = null;
FullScreenQuad quad = null;
XNAGame game = new XNAGame();
game.InitializeEvent += delegate
{
shader = new BasicShader(game);
shader.AddCustomIncludeHandler("testInclude.fx",
delegate
{
var byteArray = Encoding.ASCII.GetBytes("float getColor(){return 1;}");
return(new MemoryStream(byteArray));
});
shader.InitFromEmbeddedFile(game,
typeof(GraphicsTest).Assembly, "MHGameWork.TheWizards.Tests.Graphics.Files.TestShaderInclude.fx",
"..\\..\\Unit Tests\\Graphics\\Files\\TestShaderInclude.fx",
new EffectPool());
shader.SetTechnique("Technique1");
quad = new FullScreenQuad(game.GraphicsDevice);
};
game.DrawEvent += () => shader.RenderMultipass(() => quad.Draw());
game.Run();
}
public SimpleTerrain(XNAGame game, List <Microsoft.Xna.Framework.Vector3> positions, List <Color> colors, int vertexCountWidth, int vertexCountHeigth, Matrix world)
{
World = world;
vertices = new List <VertexPositionNormalColor>();
this.game = game;
int positionCount = positions.Count;
this.vertexCountWidth = vertexCountWidth;
for (int count = 0; count < vertexCountWidth - 1; count++)
{
for (int i = 0; i < vertexCountWidth - 1; i++)
{
vertices.Add(new VertexPositionNormalColor(positions[i + count * vertexCountWidth], GetAveragedNormal(i, count, positions), colors[i + count * vertexCountWidth]));
vertices.Add(new VertexPositionNormalColor(positions[i + (count + 1) * vertexCountWidth], GetAveragedNormal(i, count + 1, positions), colors[i + (count + 1) * vertexCountWidth]));
vertices.Add(new VertexPositionNormalColor(positions[i + count * vertexCountWidth + 1], GetAveragedNormal(i + 1, count, positions), colors[i + count * vertexCountWidth + 1]));
vertices.Add(new VertexPositionNormalColor(positions[i + count * vertexCountWidth + 1], GetAveragedNormal(i + 1, count, positions), colors[i + count * vertexCountWidth + 1]));
vertices.Add(new VertexPositionNormalColor(positions[i + (count + 1) * vertexCountWidth], GetAveragedNormal(i, count + 1, positions), colors[i + (count + 1) * vertexCountWidth]));
vertices.Add(new VertexPositionNormalColor(positions[i + (count + 1) * vertexCountWidth + 1], GetAveragedNormal(i + 1, count, positions), colors[i + (count + 1) * vertexCountWidth + 1]));
//vertices.Add(new VertexPositionNormalColor(positions[i + (count + 1) * vertexCountWidth], colors[i + (count + 1) * vertexCountWidth]));
//vertices.Add(new VertexPositionNormalColor(positions[i + count * vertexCountWidth + 1], colors[i + count * vertexCountWidth + 1]));
//vertices.Add(new VertexPositionNormalColor(positions[i + count * vertexCountWidth + 1], colors[i + count * vertexCountWidth + 1]));
//vertices.Add(new VertexPositionNormalColor(positions[i + (count + 1) * vertexCountWidth], colors[i + (count + 1) * vertexCountWidth]));
//vertices.Add(new VertexPositionNormalColor(positions[i + (count + 1) * vertexCountWidth + 1], colors[i + (count + 1) * vertexCountWidth + 1]));
}
}
vertexCount = vertices.Count;
triangleCount = vertexCount / 3;
vertexStride = VertexPositionNormalColor.SizeInBytes;
}
public static VertexDeclaration ReadVertexDeclaration(XNAGame game, TWXmlNode node)
{
if (node.Value == "NULL")
{
return(null);
}
TWXmlNode elementsNode = node.FindChildNode("Elements");
VertexElement[] elements = new VertexElement[elementsNode.GetAttributeInt("count")];
TWXmlNode[] elementNodes = elementsNode.FindChildNodes("VertexElement");
if (elementNodes.Length != elements.Length)
{
throw new InvalidOperationException("Invalid XML format!");
}
for (int i = 0; i < elementNodes.Length; i++)
{
TWXmlNode elementNode = elementNodes[i];
VertexElement element = new VertexElement();
element.Offset = Int16.Parse(elementNode.ReadChildNodeValue("Offset"));
element.Stream = Int16.Parse(elementNode.ReadChildNodeValue("Stream"));
element.UsageIndex = Byte.Parse(elementNode.ReadChildNodeValue("UsageIndex"));
element.VertexElementFormat = (VertexElementFormat)Enum.Parse(typeof(VertexElementFormat), elementNode.ReadChildNodeValue("VertexElementFormat"));
element.VertexElementMethod = (VertexElementMethod)Enum.Parse(typeof(VertexElementMethod), elementNode.ReadChildNodeValue("VertexElementMethod"));
element.VertexElementUsage = (VertexElementUsage)Enum.Parse(typeof(VertexElementUsage), elementNode.ReadChildNodeValue("VertexElementUsage"));
elements[i] = element;
}
return(new VertexDeclaration(game.GraphicsDevice, elements));
}
public void TestPhysicsMeshPoolConvexMesh()
{
XNAGame game = new XNAGame();
var mesh = new RAMMesh();
var data = mesh.GetCollisionData();
var convex = new MeshCollisionData.Convex();
convex.Positions = new List <Vector3>();
Vector3[] pos = CreatePyramidPositions();
Vector3[] transpos = new Vector3[pos.Length];
var mat = Matrix.CreateTranslation(20, 5, 20);
Vector3.Transform(pos, ref mat, transpos);
convex.Positions.AddRange(transpos);
data.ConvexMeshes.Add(convex);
PhysicsEngine engine = new PhysicsEngine();
PhysicsDebugRendererXNA debugRenderer = null;
game.InitializeEvent += delegate
{
engine.Initialize();
debugRenderer = new PhysicsDebugRendererXNA(game, engine.Scene);
debugRenderer.Initialize(game);
var pool = new MeshPhysicsPool();
var tMesh1 = pool.CreateConvexMesh(engine.Scene, mesh.GetCollisionData().ConvexMeshes[0]);
var tMesh2 = pool.CreateConvexMesh(engine.Scene, mesh.GetCollisionData().ConvexMeshes[0]);
Assert.AreEqual(tMesh1, tMesh2);
var actorDesc = new ActorDescription(new ConvexShapeDescription()
{
ConvexMesh = tMesh1
});
engine.Scene.CreateActor(actorDesc);
};
game.DrawEvent += delegate
{
debugRenderer.Render(game);
};
int frameNum = 0;
game.UpdateEvent += delegate
{
engine.Update(game.Elapsed);
//if (frameNum > 2) game.Exit();
frameNum++;
};
game.Run();
}
public void TestSyncOnlineClient()
{
var conn = NetworkingUtilities.ConnectTCP(10045, "5.149.17.16");
//var conn = NetworkingClientTest.ConnectTCP(10045, "127.0.0.1");
conn.Receiving = true;
var client = new ClientPacketManagerNetworked(conn);
var clientSyncer = new ClientSyncer(client);
var physicsEngine = new PhysicsEngine();
StillDesign.PhysX.Scene serverScene = null;
PhysicsDebugRendererXNA debugRenderer;
PhysicsDebugRendererXNA debugRendererServer;
var game = new XNAGame();
game.InitializeEvent += delegate
{
physicsEngine.Initialize();
serverScene = physicsEngine.CreateScene(physicsEngine.Scene.Gravity, true);
debugRenderer = new PhysicsDebugRendererXNA(game, physicsEngine.Scene);
game.AddXNAObject(debugRenderer);
debugRendererServer = new PhysicsDebugRendererXNA(game, serverScene);
game.AddXNAObject(debugRendererServer);
ActorDescription actorDesc;
SphereShapeDescription shape;
shape = new SphereShapeDescription(1);
actorDesc = new ActorDescription(shape);
actorDesc.BodyDescription = new BodyDescription(10);
var client1 = clientSyncer.CreateActor(physicsEngine.Scene.CreateActor(actorDesc));
client1.ID = 2; // Identify
};
game.UpdateEvent += delegate
{
physicsEngine.Update(game);
physicsEngine.UpdateScene(game.Elapsed, serverScene);
clientSyncer.Update(game.Elapsed);
};
client.SyncronizeRemotePacketIDs();
client.WaitForUDPConnected();
game.Run();
physicsEngine.Dispose();
}
public void TestRunXNAGame()
{
XNAGame game = new XNAGame();
game.DrawFps = true;
game.IsFixedTimeStep = false;
game.Run();
}
public void TestSyncOffline()
{
var serverpm = new SimpleServerPacketManager();
var clientpm = serverpm.CreateClient();
var vertexDeclarationPool = new VertexDeclarationPool();
vertexDeclarationPool.SetVertexElements <TangentVertex>(TangentVertex.VertexElements);
var texturePool = new TexturePool();
var meshPartPool = new MeshPartPool();
var renderer = new SimpleMeshRenderer(texturePool, meshPartPool, vertexDeclarationPool);
var mesh =
DefaultMeshes.CreateGuildHouseMesh(
new TheWizards.OBJParser.OBJToRAMMeshConverter(new RAMTextureFactory()));
var meshFactory = new SimpleMeshFactory();
meshFactory.AddMesh(mesh);
var builder = new SimpleStaticWorldObjectFactory(renderer, meshFactory);
var client = new ClientStaticWorldObjectSyncer(clientpm, builder);
var server = new ServerStaticWorldObjectSyncer(serverpm);
var game = new XNAGame();
game.AddXNAObject(renderer);
game.AddXNAObject(vertexDeclarationPool);
game.AddXNAObject(texturePool);
game.AddXNAObject(meshPartPool);
game.InitializeEvent += delegate
{
};
game.UpdateEvent += delegate
{
if (game.Keyboard.IsKeyPressed(Microsoft.Xna.Framework.Input.Keys.F))
{
var o = server.CreateNew();
var obj = o;
obj.Mesh = mesh;
obj.WorldMatrix = Matrix.CreateTranslation(game.SpectaterCamera.CameraPosition);
}
server.Update(game.Elapsed);
client.Update(game.Elapsed);
};
game.Run();
}
public void TestTestSphereShooter()
{
var game = new XNAGame();
game.IsFixedTimeStep = false;
//game.DrawFps = true;
PhysicsEngine engine = new PhysicsEngine();
engine.Initialize();
var debugRenderer = new PhysicsDebugRendererXNA(game, engine.Scene);
game.AddXNAObject(debugRenderer);
game.AddXNAObject(engine);
ClientPhysicsQuadTreeNode root;
int numNodes = 20;
root = new ClientPhysicsQuadTreeNode(
new BoundingBox(
new Vector3(-numNodes * numNodes / 2f, -100, -numNodes * numNodes / 2f),
new Vector3(numNodes * numNodes / 2f, 100, numNodes * numNodes / 2f)));
QuadTree.Split(root, 5);
var shooter = new TestSphereShooter(game, engine, root, game.SpectaterCamera);
game.AddXNAObject(shooter);
var visualizer = new QuadTreeVisualizerXNA();
game.DrawEvent += delegate
{
visualizer.RenderNodeGroundBoundig(game, root,
delegate(ClientPhysicsQuadTreeNode node, out Color col)
{
col = Color.Green;
return(node.PhysicsObjects.Count == 0);
});
visualizer.RenderNodeGroundBoundig(game, root,
delegate(ClientPhysicsQuadTreeNode node, out Color col)
{
col = Color.Orange;
return(node.PhysicsObjects.Count > 0);
});
};
game.Run();
}
public void TestIntervalCaller()
{
XNAGame game = new XNAGame();
IntervalCaller caller1 = null, caller2 = null;
BoxMesh box1 = null;
BoxMesh box2 = null;
box1 = new BoxMesh();
box2 = new BoxMesh();
game.AddXNAObject(box1);
game.AddXNAObject(box2);
var pos = new Vector3(2, 0, 0);
caller1 = new IntervalCaller(delegate
{
if (box1.Color.R == 255)
{
box1.Color = Color.Green;
}
else
{
box1.Color = Color.Red;
}
}, 1 / 5f);
caller2 = new IntervalCaller(delegate
{
if (pos.Z == 0)
{
pos.Z = 2;
}
else
{
pos.Z = 0;
}
box2.WorldMatrix = Matrix.CreateTranslation(pos);
}, 1 / 3f);
game.InitializeEvent += delegate
{
};
game.DrawEvent +=
delegate
{
caller1.Update(game.Elapsed);
caller2.Update(game.Elapsed);
};
game.Run();
}
public void TestXNAGameWpfEditBoxMesh()
{
var game = new XNAGame();
var mesh = new BoxMesh();
game.AddXNAObject(mesh);
game.Wpf.CreateClassForm(mesh);
game.Run();
}
public WaterTest()
{
game = new XNAGame();
game.InitializeEvent += new EventHandler(game_InitializeEvent);
game.DrawEvent += new XNAGame.XNAGameLoopEventHandler(game_DrawEvent);
game.UpdateEvent += new XNAGame.XNAGameLoopEventHandler(game_UpdateEvent);
specCam = (SpectaterCamera)game.Camera;
specCam.FarClip = 10000f;
camTemp.SetLens(MathHelper.PiOver4, 4f / 3f, specCam.NearClip, specCam.FarClip);
inCamera = true;
}
private void renderSnapInformation(XNAGame game, Matrix transformation, SnapInformation snapInformation, Dictionary <SnapType, Color> colorTypeMap)
{
for (int j = 0; j < snapInformation.SnapList.Count; j++)
{
SnapPoint point = snapInformation.SnapList[j];
Vector3 startPos = point.Position;
var color = colorTypeMap[point.SnapType];
game.LineManager3D.AddLine(Vector3.Transform(startPos, transformation), Vector3.Transform(startPos + point.Normal, transformation), color);
game.LineManager3D.AddLine(Vector3.Transform(startPos, transformation), Vector3.Transform(startPos + point.Up, transformation), color);
}
}
public XNARenderSystemProvider()
{
_game = new XNAGame();
_gdManager = new XNA.GraphicsDeviceManager(_game);
_gdManager.GraphicsProfile = XFG.GraphicsProfile.HiDef;
_gdManager.ApplyChanges();
_renderer = new XNARenderer(_gdManager.GraphicsDevice);
_device = _renderer.GraphicsDevice;
_content = new ContentManager(new EmbeddedResourceLocator(Tesla.Xna.DefaultContent.ResourceManager));
_content.UseDefaultContent = false;
}
public object LoadAsset(string type, string name)
{
try {
var loader = loaders[type];
var stream = provider.GetStream(type, name);
return(loader.Load(stream));
} catch (ContentLoadException e) {
XNAGame.Log(e.ToString());
return(null);
}
}
public object LoadContent(string type, string name)
{
var loader = loaders[type];
try {
return(loader.Load(name));
} catch (ContentLoadException e) {
XNAGame.Log(e.ToString());
return(null);
}
}
public void TestTriangleMesh()
{
XNAGame game = new XNAGame();
game.SpectaterCamera.CameraPosition = new Vector3(0, 0, -40);
PhysicsEngine engine = new PhysicsEngine();
//game.AddXNAObject(engine);
game.InitializeEvent += delegate
{
engine.Initialize();
PhysicsDebugRendererXNA debugRenderer = new PhysicsDebugRendererXNA(game, engine.Scene);
game.AddXNAObject(debugRenderer);
TangentVertex[] vertices;
short[] indices;
BoxMesh.CreateUnitBoxVerticesAndIndices(out vertices, out indices);
var positions = new Vector3[vertices.Length];
for (int i = 0; i < positions.Length; i++)
{
positions[i] = vertices[i].pos;
}
int[] intIndices = new int[indices.Length];
for (int i = 0; i < intIndices.Length; i++)
{
intIndices[i] = indices[i];
}
var triangleMesh = CreateTriangleMesh(positions, intIndices, engine.Scene);
var triangleMeshShapeDesc = new TriangleMeshShapeDescription();
triangleMeshShapeDesc.TriangleMesh = triangleMesh;
var actorDesc = new ActorDescription(triangleMeshShapeDesc);
var actor = engine.Scene.CreateActor(actorDesc);
};
game.UpdateEvent += delegate
{
engine.Update(game.Elapsed);
};
game.Run();
engine.Dispose();
}
private void testMeshPhysicsActorBuilder(RAMMesh mesh)
{
XNAGame game = new XNAGame();
BoundingBox boundingBox = new BoundingBox();
PhysicsEngine engine = new PhysicsEngine();
PhysicsDebugRendererXNA debugRenderer = null;
Matrix mirrorMatrix = Matrix.CreateScale(-1, 1, 1);
game.InitializeEvent += delegate
{
engine.Initialize();
debugRenderer = new PhysicsDebugRendererXNA(game, engine.Scene);
debugRenderer.Initialize(game);
var builder = new MeshPhysicsActorBuilder(new MeshPhysicsPool());
builder.CreateActorStatic(engine.Scene, mesh.GetCollisionData(), Matrix.Identity);
boundingBox = builder.CalculateBoundingBox(mesh.GetCollisionData());
builder.CreateActorStatic(engine.Scene, mesh.GetCollisionData(), mirrorMatrix);
};
game.DrawEvent += delegate
{
debugRenderer.Render(game);
game.LineManager3D.WorldMatrix = Matrix.Identity;
game.LineManager3D.AddBox(boundingBox, Color.Orange);
game.LineManager3D.WorldMatrix = mirrorMatrix;
game.LineManager3D.AddBox(boundingBox, Color.Yellow);
game.LineManager3D.WorldMatrix = Matrix.Identity;
};
game.UpdateEvent += delegate
{
engine.Update(game.Elapsed);
if (game.Keyboard.IsKeyPressed(Microsoft.Xna.Framework.Input.Keys.F))
{
Actor actor = PhysicsHelper.CreateDynamicSphereActor(engine.Scene, 1, 1);
actor.GlobalPosition = game.SpectaterCamera.CameraPosition +
game.SpectaterCamera.CameraDirection * 5;
actor.LinearVelocity = game.SpectaterCamera.CameraDirection * 5;
}
};
game.Run();
}
public void TestGizmo()
{
XNAGame game = new XNAGame();
EditorGizmoTranslation translationGizmo = new EditorGizmoTranslation();
EditorGrid grid = new EditorGrid();
translationGizmo.Position = new Vector3(0, 0, 0);
translationGizmo.Enabled = true;
grid.Size = new Vector2(100, 100);
grid.Interval = 1;
grid.MajorInterval = 10;
bool toggle = false;
game.InitializeEvent += delegate
{
translationGizmo.Load(game);
};
game.DrawEvent += delegate
{
game.GraphicsDevice.RenderState.CullMode = CullMode.CullClockwiseFace;
translationGizmo.Render(game);
grid.Render(game);
};
game.UpdateEvent += delegate
{
translationGizmo.Update(game);
if (game.Keyboard.IsKeyPressed(Microsoft.Xna.Framework.Input.Keys.LeftAlt))
{
toggle = !toggle;
}
if (toggle)
{
game.Mouse.CursorEnabled = true;
game.IsMouseVisible = true;
game.SpectaterCamera.Enabled = false;
}
else
{
game.Mouse.CursorEnabled = false;
game.IsMouseVisible = false;
game.SpectaterCamera.Enabled = true;
}
};
game.Run();
}
public void Combined()
{
XNAGame game = new XNAGame();
game.SpectaterCamera.FarClip = 10000;
PerlinNoiseGenerater noise;
PerlinNoiseGenerater colorNoise;
noise = new PerlinNoiseGenerater();
colorNoise = new PerlinNoiseGenerater();
float frequency = 0.5f;
///float factor = 0.02f;
float scale = 100f;
List <Vector3> positions = new List <Vector3>();
List <Color> colors = new List <Color>();
int width = 5000;
int height = 5000;
float verticesPerMeter = 0.1f;
int verticesX = (int)(width * verticesPerMeter);
int verticesY = (int)(height * verticesPerMeter);
SimpleTerrain terrain;
noise.NumberOfOctaves = 4;
noise.persistance = 0.5f;
for (int i = 0; i < verticesX; i++)
{
for (int j = 0; j < verticesY; j++)
{
// combinedFractalBrowning (float x,float y,int octaves,float lacunarityFractal,float lacunarityRidge,float gainFractal,float gainRidge,float offset,float distribution )
float zValue = noise.CombinedFractalBrowningAndRidgedMF(i / verticesPerMeter, j / verticesPerMeter, 8, 4, 4, 0.3f, 0.2f, 1.2f, 0.8f) * scale;
positions.Add(new Vector3(i / verticesPerMeter, zValue, j / verticesPerMeter));
colors.Add(heightColoring(zValue, j + i * verticesX));
//colors.Add(new Color((byte)(150 * colorNoise.interpolatedNoise(i * frequency, j * frequency)), (byte)(100 + 70 * colorNoise.interpolatedNoise((i + 1) * frequency, (j + 1) * frequency)), (byte)(140 * colorNoise.interpolatedNoise(i * frequency, (j + 2) * frequency))));
}
}
terrain = new SimpleTerrain(game, positions, colors, verticesX, verticesY);
game.InitializeEvent +=
delegate
{
terrain.CreateRenderData();
};
game.DrawEvent +=
delegate
{
terrain.Render();
};
game.Run();
}
public void TestMeshPartPool()
{
XNAGame game = new XNAGame();
game.DrawFps = true;
var pool = new MeshPartPool();
game.AddXNAObject(pool);
RAMMeshPart meshPart = new RAMMeshPart();
meshPart.SetGeometryData(MeshPartGeometryData.CreateTestSquare());
DefaultModelShader shader = null;
VertexDeclaration decl = null;
game.InitializeEvent += delegate
{
decl = TangentVertexExtensions.CreateVertexDeclaration(game);
shader = new DefaultModelShader(game, new EffectPool());
shader.DiffuseColor = Color.Red.ToVector4();
shader.Technique = DefaultModelShader.TechniqueType.Colored;
};
game.DrawEvent += delegate
{
game.GraphicsDevice.RenderState.CullMode = CullMode.None;
game.GraphicsDevice.VertexDeclaration = decl;
shader.ViewProjection = game.Camera.ViewProjection;
shader.World = Matrix.CreateTranslation(Vector3.Right * 0 * 3) * Matrix.CreateScale(10);
shader.DrawPrimitives(delegate
{
var vb = pool.GetVertexBuffer(meshPart);
var ib = pool.GetIndexBuffer(meshPart);
var vertexCount =
meshPart.GetGeometryData().GetSourceVector3(MeshPartGeometryData.Semantic.Position).Length;
game.GraphicsDevice.Vertices[0].SetSource(vb, 0, TangentVertex.SizeInBytes);
game.GraphicsDevice.Indices = ib;
game.GraphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, vertexCount, 0, vertexCount / 3);
});
};
game.Run();
}
