public List <RAMMesh> CreateMeshesFromObjects(ObjImporter importer)
{
var meshes = new List <RAMMesh>();
Dictionary <OBJMaterial, MeshCoreData.Material> materials = convertMaterials(importer);
for (int i = 0; i < importer.Groups.Count; i++)
{
var group = importer.Groups[i];
var mesh = new RAMMesh();
meshes.Add(mesh);
for (int j = 0; j < group.SubObjects.Count; j++)
{
var sub = group.SubObjects[j];
convertSubObject(importer, sub, materials, mesh);
}
if (!meshHasCollisionData(mesh))
{
mesh.GetCollisionData().TriangleMesh = createTriangleMeshForGroup(importer, group);
}
}
return(meshes);
}
public void TestMeshPhysicsActorBuilderTriangleMesh()
{
var mesh = new RAMMesh();
var data = mesh.GetCollisionData();
var triangleMesh = new MeshCollisionData.TriangleMeshData();
Vector3[] pos = CreatePyramidPositions();
Vector3[] transpos = new Vector3[pos.Length];
var mat = Matrix.CreateTranslation(20, 5, 20);
Vector3.Transform(pos, ref mat, transpos);
triangleMesh.Positions = transpos;
triangleMesh.Indices = new int[triangleMesh.Positions.Length];
for (int i = 0; i < triangleMesh.Positions.Length; i++)
{
triangleMesh.Indices[i] = i;
}
data.TriangleMesh = triangleMesh;
testMeshPhysicsActorBuilder(mesh);
}
public void TestOptimizeMeshManyParts()
{
var b = new MeshBuilder();
b.AddBox(new Vector3(0, 0, 0), new Vector3(1, 1, 1));
var partMesh = b.CreateMesh();
var unoptimized = new RAMMesh();
for (int i = 0; i < 1000; i++)
{
MeshBuilder.AppendMeshTo(partMesh, unoptimized, Matrix.Translation(i, 0, 0));
}
var optimizer = new MeshOptimizer();
var watch = new Stopwatch();
watch.Start();
for (int i = 0; i < 10; i++)
{
var optimized = optimizer.CreateOptimized(unoptimized);
Assert.AreEqual(1, optimized.GetCoreData().Parts.Count);
}
watch.Stop();
Console.WriteLine(watch.Elapsed.TotalMilliseconds / 10);
}
private void drawMesh(RAMMesh mesh)
{
GraphicsDevice.RenderState.CullMode = CullMode.None;
GraphicsDevice.VertexDeclaration = tangentVertexDeclaration;
var data = mesh.GetCoreData();
for (int i = 0; i < data.Parts.Count; i++)
{
var part = data.Parts[i];
renderGBufferShader.SetParameter("World", part.ObjectMatrix);
if (part.MeshMaterial.DiffuseMap == null)
{
renderGBufferShader.SetParameter("Texture", checkerTexture);
}
else
{
renderGBufferShader.SetParameter("Texture", texturePool.LoadTexture(part.MeshMaterial.DiffuseMap));
}
GraphicsDevice.Vertices[0].SetSource(meshPartPool.GetVertexBuffer(part.MeshPart), 0,
TangentVertex.SizeInBytes);
GraphicsDevice.Indices = meshPartPool.GetIndexBuffer(part.MeshPart);
int numVertices =
part.MeshPart.GetGeometryData().GetSourceVector3(MeshPartGeometryData.Semantic.Position).Length;
renderGBufferShader.RenderMultipass(delegate
{
GraphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, numVertices, 0, numVertices / 3);
});
}
}
private void convertCollisionData(ObjImporter importer, RAMMesh mesh)
{
//var boxMaterial = importer.Materials.Find(o => o.Name == "TW-Physics-Box");
for (int i = 0; i < importer.Groups.Count; i++)
{
var group = importer.Groups[i];
for (int j = 0; j < group.SubObjects.Count; j++)
{
var subObj = group.SubObjects[j];
if (subObj.Material.Name == materialNamePhysicsBox)
{
convertSubObjectPhysicsBox(importer, subObj, mesh);
}
}
}
var data = mesh.GetCollisionData();
if (!meshHasCollisionData(mesh))
{
//Load triangle mesh from positions
MeshCollisionData.TriangleMeshData tm = createTriangleMeshForAllObjects(importer);
data.TriangleMesh = tm;
}
}
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();
}
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);
}
private IMesh BuildChunkMesh(Point2 offset, Point2 size)
{
IMesh batch = new RAMMesh();
size.ForEach(p =>
{
var v = world.GetVoxel(p + new Point2(offset));
if (v == null)
{
return;
}
var mesh = meshProvider.GetMesh(v);
if (mesh == null)
{
return;
}
var vWorld = Matrix.Scaling(new Vector3(world.VoxelSize.X))
* Matrix.Translation(((p.ToVector2() + new Vector2(0.5f)) * world.VoxelSize.X).ToXZ(v.Data.Height));
MeshBuilder.AppendMeshTo(meshProvider.GetMesh(v), batch, vWorld);
});
var optimizer = new MeshOptimizer();
batch = optimizer.CreateOptimized(batch);
return(batch);
}
private void drawMeshShadowMap(RAMMesh mesh)
{
GraphicsDevice.RenderState.CullMode = CullMode.None;
GraphicsDevice.VertexDeclaration = tangentVertexDeclaration;
var data = mesh.GetCoreData();
for (int i = 0; i < data.Parts.Count; i++)
{
var part = data.Parts[i];
shadowMapShader.SetParameter("g_matWorld", part.ObjectMatrix);
GraphicsDevice.Vertices[0].SetSource(meshPartPool.GetVertexBuffer(part.MeshPart), 0,
TangentVertex.SizeInBytes);
GraphicsDevice.Indices = meshPartPool.GetIndexBuffer(part.MeshPart);
int numVertices =
part.MeshPart.GetGeometryData().GetSourceVector3(MeshPartGeometryData.Semantic.Position).Length;
shadowMapShader.RenderMultipass(delegate
{
GraphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, numVertices, 0, numVertices / 3);
});
}
}
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 Build()
{
IMesh mesh = new RAMMesh();
foreach (var ent in entities)
{
MeshBuilder.AppendMeshTo(ent.Mesh, mesh, ent.WorldMatrix);
ent.Batched = true;
ent.get <BatchInfo>().Batch = this;
}
var optimizer = new MeshOptimizer();
mesh = optimizer.CreateOptimized(mesh);
element = TW.Graphics.AcquireRenderer().CreateMeshElement(mesh);
}
public void TestMeshRendererAdvanced()
{
var texFactory = new RAMTextureFactory();
var c = new OBJToRAMMeshConverter(texFactory);
var game = new XNAGame();
game.IsFixedTimeStep = false;
game.DrawFps = true;
var importer = new ObjImporter();
importer.AddMaterialFileStream("Crate01.mtl", File.OpenRead(TestFiles.CrateMtl));
importer.ImportObjFile(TestFiles.CrateObj);
var mesh = c.CreateMesh(importer);
RAMMesh mesh2 = DefaultMeshes.CreateMerchantsHouseMesh(c);
RAMMesh mesh3 = DefaultMeshes.CreateGuildHouseMesh(c);
SimpleMeshRenderer renderer = InitDefaultMeshRenderer(game);
var el = renderer.AddMesh(mesh);
el.WorldMatrix = Matrix.CreateTranslation(Vector3.Right * 0 * 2 + Vector3.UnitZ * 0 * 2);
el = renderer.AddMesh(mesh2);
el.WorldMatrix = Matrix.CreateTranslation(new Vector3(0, 0, 80));
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
el = renderer.AddMesh(mesh3);
el.WorldMatrix = Matrix.CreateTranslation(new Vector3(j * 30, 0, 70 + i * 30));
}
}
game.Run();
}
private void createNewWorldObjectType(TileSnapInformationBuilder builder)
{
RAMMesh mesh = getMeshFromUser();
if (mesh == null)
{
return;
}
var worldObjectType = new WorldObjectType(mesh, Guid.NewGuid(), builder);
var tileData = new TileData(Guid.NewGuid());
tileData.Mesh = mesh;
tileData.Dimensions = new Vector3(1.5f, 2, 1.5f) - new Vector3(-1.5f, -2, -1.5f);
worldObjectType.TileData = tileData;
addType(worldObjectType);
}
public void TestPhysicsMeshPoolTriangleMeshPreload()
{
XNAGame game = new XNAGame();
RAMMesh mesh = createTriangleMesh();
PhysicsEngine engine = new PhysicsEngine();
MeshPhysicsPool pool = null;
game.InitializeEvent += delegate
{
engine.Initialize();
pool = new MeshPhysicsPool();
pool.PreloadTriangleMesh(engine.Scene, mesh.GetCollisionData().TriangleMesh);
};
game.DrawEvent += delegate
{
};
int frameNum = 0;
game.UpdateEvent += delegate
{
System.Threading.Thread.Sleep(1000);
pool.Update(engine.Scene);
// This should finish instantly
var tMesh1 = pool.CreateTriangleMesh(engine.Scene, mesh.GetCollisionData().TriangleMesh);
engine.Update(game.Elapsed);
if (frameNum > 2)
{
game.Exit();
}
frameNum++;
};
game.Run();
}
public void TestSerializeTileData()
{
TileData data = new TileData(Guid.NewGuid());
TileFaceType type = new TileFaceType(Guid.NewGuid());
type.FlipWinding = true;
TileFaceType root = new TileFaceType(Guid.NewGuid());
type.SetParent(root);
data.Dimensions = new Vector3(1, 2, 3);
data.SetFaceType(TileFace.Front, type);
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);
data.Mesh = meshWallInnerCorner;
var simpleMeshFactory = new SimpleMeshFactory();
simpleMeshFactory.AddMesh(meshWallInnerCorner);
DiskTileDataFactory diskTileDataFactory = new DiskTileDataFactory(simpleMeshFactory,
new SimpleTileFaceTypeFactory());
FileStream stream = File.OpenWrite(TWDir.Test.CreateSubdirectory("TileEngine").FullName + "\\TestTileData.xml");
diskTileDataFactory.SerializeTileData(data, stream);
stream.Close();
FileStream readStream =
File.OpenRead(TWDir.Test.CreateSubdirectory("TileEngine").FullName + "\\TestTileData.xml");
TileData readData = diskTileDataFactory.DeserializeTileData(readStream);
readStream.Close();
}
public void TestMeshPhysicsActorBuilderConvex()
{
var mesh = new RAMMesh();
var data = mesh.GetCollisionData();
var convexMesh = new MeshCollisionData.Convex();
convexMesh.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);
convexMesh.Positions.AddRange(transpos);
data.ConvexMeshes.Add(convexMesh);
testMeshPhysicsActorBuilder(mesh);
}
private RAMMesh createTwoBoxMesh()
{
var mesh = new RAMMesh();
var data = mesh.GetCollisionData();
var box = new MeshCollisionData.Box();
box.Dimensions = Vector3.One * 2;
box.Orientation = Matrix.Identity;
data.Boxes.Add(box);
box = new MeshCollisionData.Box();
box.Dimensions = Vector3.One * 4;
box.Orientation = Matrix.CreateTranslation(new Vector3(2, 2, 2));
data.Boxes.Add(box);
return(mesh);
}
public static IMesh CreateSimpleTestMesh()
{
IMesh mesh;
mesh = new RAMMesh();
var part = new MeshCoreData.Part();
part.ObjectMatrix = Matrix.Identity;
part.MeshPart = new RAMMeshPart();
((RAMMeshPart)part.MeshPart).SetGeometryData(MeshPartGeometryData.CreateTestSquare());
var mat = new MeshCoreData.Material();
mat.DiffuseMap = GetTestTexture();
part.MeshMaterial = mat;
mesh.GetCoreData().Parts.Add(part);
return(mesh);
}
public MeshCollisionData.Box CreateCollisionBox(OBJGroup.SubObject subObj, RAMMesh mesh)
{
var data = mesh.GetCollisionData();
var positions = new List <Vector3>();
for (int i = 0; i < subObj.Faces.Count; i++)
{
var face = subObj.Faces[i];
positions.Add(importer.Vertices[face.V1.Position]);
positions.Add(importer.Vertices[face.V2.Position]);
positions.Add(importer.Vertices[face.V3.Position]);
}
var bb = BoundingBox.CreateFromPoints(positions);
var box = new MeshCollisionData.Box();
box.Dimensions = bb.Max - bb.Min;
box.Orientation = Matrix.CreateTranslation((bb.Max + bb.Min) * 0.5f);
return(box);
}
public void TestMeshPhysicsActorBuilderBoxes()
{
var mesh = new RAMMesh();
var data = mesh.GetCollisionData();
var box = new MeshCollisionData.Box();
box.Dimensions = Vector3.One;
box.Orientation = Matrix.Identity;
data.Boxes.Add(box);
box = new MeshCollisionData.Box();
box.Dimensions = Vector3.One * 3;
box.Orientation = Matrix.CreateTranslation(new Vector3(2, 2, 2));
data.Boxes.Add(box);
testMeshPhysicsActorBuilder(mesh);
}
public RAMMesh CreateMesh(ObjImporter importer)
{
var mesh = new RAMMesh();
//TODO: additional data
/*var meshAdditionalData = new MeshAdditionalData();
* meshAdditionalData.ImportedDate = DateTime.Now;
* meshAdditionalData.ImporterDescription = "Imported by the OBJToRAMMeshConverter using the OBJImporter";*/
var meshCoreData = mesh.GetCoreData();
Dictionary <OBJMaterial, MeshCoreData.Material> materials = convertMaterials(importer);
for (int i = 0; i < importer.Groups.Count; i++)
{
var group = importer.Groups[i];
for (int j = 0; j < group.SubObjects.Count; j++)
{
var sub = group.SubObjects[j];
if (sub.Faces.Count == 0)
{
continue;
}
if (sub.Material.Name == materialNamePhysicsBox)
{
continue;
}
convertSubObject(importer, sub, materials, mesh);
}
}
convertCollisionData(importer, mesh);
return(mesh);
}
private void clearState()
{
lights = new List <PointLight>();
mesh = new RAMMesh();
}
private void convertSubObjectPhysicsConvexMesh(ObjImporter importer, OBJGroup.SubObject sub, RAMMesh mesh)
{
var positions = new List <Vector3>();
addPositionsFromSubObject(importer, sub, positions);
var convex = new MeshCollisionData.Convex();
convex.Positions = positions;
mesh.GetCollisionData().ConvexMeshes.Add(convex);
}
public DeferredRendererOud(RAMMesh merchantsHouseMesh, string woodPlanksBarePath)
{
this.merchantsHouseMesh = merchantsHouseMesh;
this.woodPlanksBarePath = woodPlanksBarePath;
}
public void Initialize(IXNAGame _game)
{
game = _game;
//get the sizes of the backbuffer, in order to have matching render targets
int backBufferWidth = _game.GraphicsDevice.PresentationParameters.BackBufferWidth;
int backBufferHeight = _game.GraphicsDevice.PresentationParameters.BackBufferHeight;
initializeDeferredRendering(_game, backBufferWidth, backBufferHeight);
initializeDeferredShading(_game, backBufferWidth, backBufferHeight);
ambientOcclusionRT = new RenderTarget2D(_game.GraphicsDevice, backBufferWidth,
backBufferHeight, 1, SurfaceFormat.Color); //TODO: use better channel here
blurRT = new RenderTarget2D(_game.GraphicsDevice, backBufferWidth,
backBufferHeight, 1, SurfaceFormat.Color); //TODO: use better channel here
downsampleSize = new Point(backBufferWidth / 2, backBufferHeight / 2);
downsampleHalfPixel.X = 0.5f / downsampleSize.X;
downsampleHalfPixel.Y = 0.5f / downsampleSize.Y;
downsampleRT = new RenderTarget2D(_game.GraphicsDevice, downsampleSize.X,
downsampleSize.Y, 1, SurfaceFormat.Color);
downsampleBlurYRT = new RenderTarget2D(_game.GraphicsDevice, downsampleSize.X,
downsampleSize.Y, 1, SurfaceFormat.Color);
deferredShader = loadShader("DeferredShader.fx");
ambientOcclusionShader = loadShader("AmbientOcclusion.fx");
blurShader = loadShader("Blur.fx");
downsampleShader = loadShader("Downsample.fx");
fullScreenQuad = new FullScreenQuad(GraphicsDevice);
tangentVertexDeclaration = TangentVertexExtensions.CreateVertexDeclaration(game);
mesh = merchantsHouseMesh;
texturePool = new Rendering.TexturePool();
texturePool.Initialize(game);
meshPartPool = new MeshPartPool();
meshPartPool.Initialize(game);
boxTexture = Texture2D.FromFile(GraphicsDevice, new FileStream(woodPlanksBarePath, FileMode.Open, FileAccess.Read, FileShare.Read));
halfPixel.X = 0.5f / GraphicsDevice.PresentationParameters.BackBufferWidth;
halfPixel.Y = 0.5f / GraphicsDevice.PresentationParameters.BackBufferHeight;
checkerTexture = Texture2D.FromFile(game.GraphicsDevice,
EmbeddedFile.GetStream(
"MHGameWork.TheWizards.Rendering.Files.Checker.png", "Checker.png"));
randomNormalsTexture = Texture2D.FromFile(game.GraphicsDevice,
EmbeddedFile.GetStream(
"MHGameWork.TheWizards.Rendering.Deferred.Files.RandomNormals.png", "RandomNormals.png"));
initializeToneMap();
}
private void convertSubObjectRenderPart(RAMMesh mesh, OBJGroup.SubObject sub, ObjImporter importer, Dictionary <OBJMaterial, MeshCoreData.Material> materials)
{
if (sub.Faces.Count == 0)
{
return;
}
var meshCoreData = mesh.GetCoreData();
Vector3[] positions = new Vector3[sub.Faces.Count * 3];
Vector3[] normals = new Vector3[sub.Faces.Count * 3];
Vector2[] texcoords = new Vector2[sub.Faces.Count * 3];
for (int k = 0; k < sub.Faces.Count; k++)
{
var face = sub.Faces[k];
positions[k * 3 + 0] = importer.Vertices[face.V1.Position];
positions[k * 3 + 1] = importer.Vertices[face.V2.Position];
positions[k * 3 + 2] = importer.Vertices[face.V3.Position];
normals[k * 3 + 0] = importer.Normals[face.V1.Normal];
normals[k * 3 + 1] = importer.Normals[face.V2.Normal];
normals[k * 3 + 2] = importer.Normals[face.V3.Normal];
texcoords[k * 3 + 0] = new Vector2(importer.TexCoords[face.V1.TextureCoordinate].X, 1 - importer.TexCoords[face.V1.TextureCoordinate].Y);
texcoords[k * 3 + 1] = new Vector2(importer.TexCoords[face.V2.TextureCoordinate].X, 1 - importer.TexCoords[face.V2.TextureCoordinate].Y);
texcoords[k * 3 + 2] = new Vector2(importer.TexCoords[face.V3.TextureCoordinate].X, 1 - importer.TexCoords[face.V3.TextureCoordinate].Y);
}
TangentSolver solver = new TangentSolver();
var tangents = solver.GenerateTangents(positions, normals, texcoords).Select(f => new Vector3(f.X, f.Y, f.Z)).ToArray();
var positionsSource = new MeshPartGeometryData.Source();
positionsSource.DataVector3 = positions;
positionsSource.Semantic = MeshPartGeometryData.Semantic.Position;
var normalsSource = new MeshPartGeometryData.Source();
normalsSource.DataVector3 = normals;
normalsSource.Semantic = MeshPartGeometryData.Semantic.Normal;
var texcoordsSource = new MeshPartGeometryData.Source();
texcoordsSource.DataVector2 = texcoords;
texcoordsSource.Semantic = MeshPartGeometryData.Semantic.Texcoord;
var tangentsSource = new MeshPartGeometryData.Source();
tangentsSource.DataVector3 = tangents;
tangentsSource.Semantic = MeshPartGeometryData.Semantic.Tangent;
var part = new MeshCoreData.Part();
part.MeshMaterial = materials[sub.Material];
var meshPart = new RAMMeshPart();
meshPart.GetGeometryData().Sources.Add(positionsSource);
meshPart.GetGeometryData().Sources.Add(normalsSource);
meshPart.GetGeometryData().Sources.Add(texcoordsSource);
meshPart.GetGeometryData().Sources.Add(tangentsSource);
part.MeshPart = meshPart;
part.ObjectMatrix = Matrix.Identity;
meshCoreData.Parts.Add(part);
}
private bool meshHasCollisionData(RAMMesh mesh)
{
var data = mesh.GetCollisionData();
return(!(data.Boxes.Count == 0 && data.TriangleMesh == null && data.ConvexMeshes.Count == 0));
}
public void TestSerializeWorld()
{
var game = new XNAGame();
var texturePool = new TexturePool();
var meshpartPool = new MeshPartPool();
var vertexDeclarationPool = new VertexDeclarationPool();
vertexDeclarationPool.SetVertexElements <TangentVertex>(TangentVertex.VertexElements);
var renderer = new SimpleMeshRenderer(texturePool, meshpartPool, vertexDeclarationPool);
TileData data = new TileData(Guid.NewGuid());
TileFaceType type = new TileFaceType(Guid.NewGuid());
type.FlipWinding = true;
TileFaceType root = new TileFaceType(Guid.NewGuid());
type.SetParent(root);
data.Dimensions = new Vector3(1, 2, 3);
data.SetFaceType(TileFace.Front, type);
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);
data.Mesh = meshWallInnerCorner;
var builder = new TileSnapInformationBuilder();
var world = new World();
var objType = new WorldObjectType(data.Mesh, Guid.NewGuid(), builder);
objType.TileData = data;
var obj = world.CreateNewWorldObject(game, objType, renderer);
obj.Position = Vector3.One * 3;
var simpleMeshFactory = new SimpleMeshFactory();
simpleMeshFactory.AddMesh(meshWallInnerCorner);
DiskTileDataFactory diskTileDataFactory = new DiskTileDataFactory(simpleMeshFactory,
new SimpleTileFaceTypeFactory());
diskTileDataFactory.AddTileData(data);
var typeFactory = new SimpleWorldObjectTypeFactory();
var serializer = new WorldSerializer(simpleMeshFactory, diskTileDataFactory, game, renderer, typeFactory, builder);
FileStream stream = File.OpenWrite(TWDir.Test.CreateSubdirectory("TileEngine").FullName + "\\TestWorld.xml");
serializer.SerializeWorld(world, stream);
stream.Close();
FileStream readStream =
File.OpenRead(TWDir.Test.CreateSubdirectory("TileEngine").FullName + "\\TestWorld.xml");
var readWorld = new World();
serializer.DeserializeWorld(readWorld, readStream);
readStream.Close();
}
public void TestThrowBarrels()
{
var texFactory = new RAMTextureFactory();
var c = new OBJToRAMMeshConverter(texFactory);
RAMMesh mesh = OBJParserTest.GetBarrelMesh(c);
var texturePool = new TexturePool();
var meshpartPool = new MeshPartPool();
var vertexDeclarationPool = new VertexDeclarationPool();
var renderer = new SimpleMeshRenderer(texturePool, meshpartPool, vertexDeclarationPool);
vertexDeclarationPool.SetVertexElements <TangentVertex>(TangentVertex.VertexElements);
var gameMeshes = new List <OBJParserTest.TestGameMesh>();
var engine = new PhysicsEngine();
PhysicsDebugRendererXNA debugRenderer = null;
var root = CreatePhysicsQuadtree(16, 4);
var physicsElementFactoryXNA = new MeshPhysicsFactoryXNA(engine, root);
var physicsElementFactory = physicsElementFactoryXNA.Factory;
var game = new XNAGame();
game.IsFixedTimeStep = false;
game.DrawFps = true;
var visualizer = new QuadTreeVisualizerXNA();
game.AddXNAObject(physicsElementFactoryXNA);
game.AddXNAObject(texturePool);
game.AddXNAObject(meshpartPool);
game.AddXNAObject(vertexDeclarationPool);
game.AddXNAObject(renderer);
game.InitializeEvent += delegate
{
engine.Initialize();
debugRenderer = new PhysicsDebugRendererXNA(game, engine.Scene);
debugRenderer.Initialize(game);
};
bool showPhysics = true;
game.DrawEvent += delegate
{
if (game.Keyboard.IsKeyPressed(Keys.P))
{
showPhysics = !showPhysics;
}
if (showPhysics)
{
debugRenderer.Render(game);
}
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.UpdateEvent += delegate
{
engine.Update(game.Elapsed);
if (game.Keyboard.IsKeyPressed(Microsoft.Xna.Framework.Input.Keys.F))
{
var pEl = physicsElementFactory.CreateDynamicElement(mesh,
Matrix.CreateTranslation(
game.SpectaterCamera.CameraPosition +
game.SpectaterCamera.CameraDirection));
pEl.Actor.LinearVelocity = game.SpectaterCamera.CameraDirection * 30;
var rEl = renderer.AddMesh(mesh);
gameMeshes.Add(new OBJParserTest.TestGameMesh(rEl, pEl));
}
for (int i = 0; i < gameMeshes.Count; i++)
{
var m = gameMeshes[i];
m.RenderElement.WorldMatrix = m.PhysicsElement.World;
}
};
game.Run();
}
public void TestMeshRendererAdvanced()
{
var texFactory = new RAMTextureFactory();
var c = new OBJToRAMMeshConverter(texFactory);
var game = new DX11Game();
game.InitDirectX();
var context = game.Device.ImmediateContext;
var importer = new ObjImporter();
importer.AddMaterialFileStream("Crate01.mtl", File.OpenRead(TestFiles.CrateMtl));
importer.ImportObjFile(TestFiles.CrateObj);
var mesh = c.CreateMesh(importer);
RAMMesh mesh2 = RenderingTestsHelper.CreateMerchantsHouseMesh(c);
RAMMesh mesh3 = RenderingTestsHelper.CreateGuildHouseMesh(c);
var gBuffer = new GBuffer(game.Device, 800, 600);
DeferredMeshesRenderer renderer = InitDefaultMeshRenderer(game, gBuffer);
var el = renderer.AddMesh(mesh);
el.WorldMatrix = Matrix.Translation(MathHelper.Right * 0 * 2 + Vector3.UnitZ * 0 * 2);
el = renderer.AddMesh(mesh2);
el.WorldMatrix = Matrix.Translation(new Vector3(0, 0, 80));
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
el = renderer.AddMesh(mesh3);
el.WorldMatrix = Matrix.Translation(new Vector3(j * 30, 0, 70 + i * 30));
}
}
game.GameLoopEvent += delegate
{
gBuffer.Clear();
gBuffer.SetTargetsToOutputMerger();
context.Rasterizer.State = game.HelperStates.RasterizerShowAll;
renderer.Draw();
context.ClearState();
game.SetBackbuffer();
GBufferTest.DrawGBuffer(game, gBuffer);
};
game.Run();
}
