/// <summary>
/// Test car physics on a plane (xy) with some dummy guard rail for
/// simple colision checking.
/// </summary>
public static void TestCarPhysicsOnPlaneWithGuardRails()
{
PlaneRenderer plane = null;
// Use a simple object to simulate our guard rails we have in the game.
Model guardRailModel = null;
TestGame.Start("TestCarPhysicsOnPlaneWithGuardRails",
delegate
{
plane = new PlaneRenderer(Vector3.Zero,
new Plane(new Vector3(0, 0, 1), 0),
new Material("CityGround", "CityGroundNormal"), 500.0f);
//new Material("Road", "RoadNormal"), 500.0f);
guardRailModel = new Model("RoadColumnSegment");
// Put car 10m above the ground to test gravity and ground plane!
SpeedyRacerManager.Player.SetCarPosition(
new Vector3(0, 0, 10),
new Vector3(0, 1, 0),
new Vector3(0, 0, 1));
// Make sure we are not in free camera mode and can control the car
SpeedyRacerManager.Player.FreeCamera = false;
},
delegate
{
// Test slow computers by slowing down the framerate with Ctrl
if (Input.Keyboard.IsKeyDown(Keys.LeftControl))
Thread.Sleep(75);
SpeedyRacerManager.Player.SetGroundPlaneAndGuardRails(
new Vector3(0, 0, 0), new Vector3(0, 0, 1),
// Use our guardrails, always the same in this test!
new Vector3(-10, 0, 0), new Vector3(-10, 10, 0),
new Vector3(+10, 0, 0), new Vector3(+10, 10, 0));
Matrix carMatrix = SpeedyRacerManager.Player.UpdateCarMatrixAndCamera();
// Generate shadows, just the car does shadows
ShaderEffect.shadowMapping.GenerateShadows(
delegate
{
SpeedyRacerManager.CarModel.GenerateShadow(carMatrix);
});
// Render shadows (on both the plane and the car)
ShaderEffect.shadowMapping.RenderShadows(
delegate
{
SpeedyRacerManager.CarModel.UseShadow(carMatrix);
plane.UseShadow();
});
BaseGame.UI.RenderGameBackground();
// Show car and ground plane
SpeedyRacerManager.CarModel.RenderCar(false, carMatrix);
plane.Render();
// Just add brake tracks (we don't render the landscape here)
SpeedyRacerManager.Landscape.RenderBrakeTracks();
guardRailModel.Render(new Vector3(-11.5f, 2.5f, 0));
BaseGame.MeshRenderManager.Render();
// Add shadows
ShaderEffect.shadowMapping.ShowShadows();
SpeedyRacerManager.Player.DisplayPhysicsValuesAndHelp();
});
}
/// <summary>
/// Create landscape.
/// This constructor should only be called
/// from the SpeedyRacer main class!
/// </summary>
/// <param name="setLevel">Level we want to load</param>
internal Landscape()
{
#region Load map height data
#if OBS_DOESNT_WORK_ON_XBOX360
// Ok, load map grid heights. We can't load this as a Bitmap
// because we don't have the System.Drawing namespace in XNA.
// We also can't use BitmapContent or PixelBitmapContent<Color> from
// the Microsoft.XNA.Framework.Content.Pipeline namespace because
// our content is not compatible with that (its just a texture).
Texture2D tex =
BaseGame.Content.Load<Texture2D>(
Path.Combine(Directories.ContentDirectory, "LandscapeGridHeights"));
/*old
Texture2D.FromFile(BaseGame.Device,
"Textures\\LandscapeGridHeights.png");
*/
if (tex.Width != GridWidth ||
tex.Height != GridHeight)
throw new Exception(tex.Name + " has the resolution of " +
tex.Width + "x" + tex.Height + ", but for the landscape we need " +
GridWidth + "x" + GridHeight + "!");
// With help of GetData we can get to the data.
Color[] texData = new Color[GridWidth * GridHeight];
tex.GetData<Color>(texData, 0, GridWidth * GridHeight);
//tst: Log.Write("Pixel 0, 0=" + texData[0]);
#endif
FileStream file = FileHelper.LoadGameContentFile(
"Content\\"+LandscapeHeightsDataFilename);
byte[] heights = new byte[GridWidth * GridHeight];
file.Read(heights, 0, GridWidth*GridHeight);
file.Close();
mapHeights = new float[GridWidth, GridHeight];
#endregion
#region Build tangent vertices
// Build our tangent vertices
for (int x = 0; x < GridWidth; x++)
for (int y = 0; y < GridHeight; y++)
{
// Step 1: Calculate position
int index = x + y * GridWidth;
Vector3 pos = CalcLandscapePos(x, y, heights);//texData);
mapHeights[x, y] = pos.Z;
vertices[index].pos = pos;
//if (x == 0)
// Log.Write("vertices " + y + ": " + pos);
// Step 2: Calculate all edge vectors (for normals and tangents)
// This involves quite complicated optimizations and mathematics,
// hard to explain with just a comment. Read my book :D
Vector3 edge1 = pos - CalcLandscapePos(x, y + 1, heights);//texData);
Vector3 edge2 = pos - CalcLandscapePos(x + 1, y, heights);//texData);
Vector3 edge3 = pos - CalcLandscapePos(x - 1, y + 1, heights);//texData);
Vector3 edge4 = pos - CalcLandscapePos(x + 1, y + 1, heights);//texData);
Vector3 edge5 = pos - CalcLandscapePos(x - 1, y - 1, heights);//texData);
// Step 3: Calculate normal based on the edges (interpolate
// from 3 cross products we build from our edges).
vertices[index].normal = Vector3.Normalize(
Vector3.Cross(edge2, edge1) +
Vector3.Cross(edge4, edge3) +
Vector3.Cross(edge3, edge5));
// Step 4: Set tangent data, just use edge1
vertices[index].tangent = Vector3.Normalize(edge1);
// Step 5: Set texture coordinates, use full 0.0f to 1.0f range!
vertices[index].uv = new Vector2(
//x / (float)(GridWidth - 1),
//y / (float)(GridHeight - 1));
y / (float)(GridHeight - 1),
x / (float)(GridWidth - 1));
} // for for (int)
#endregion
#region Smooth normals
// Smooth all normals, first copy them over, then smooth everything
Vector3[,] normalsForSmoothing = new Vector3[GridWidth, GridHeight];
for (int x = 0; x < GridWidth; x++)
for (int y = 0; y < GridHeight; y++)
{
int index = x + y * GridWidth;
normalsForSmoothing[x, y] = vertices[index].normal;
} // for for (int)
// Time to smooth to normals we just saved
for (int x = 1; x < GridWidth - 1; x++)
for (int y = 1; y < GridHeight - 1; y++)
{
int index = x + y * GridWidth;
// Smooth 3x3 normals, but still use old normal to 40% (5 of 13)
Vector3 normal = vertices[index].normal * 4;
for (int xAdd = -1; xAdd <= 1; xAdd++)
for (int yAdd = -1; yAdd <= 1; yAdd++)
normal += normalsForSmoothing[x+xAdd, y+yAdd];
vertices[index].normal = Vector3.Normalize(normal);
// Also recalculate tangent to let it stay 90 degrees on the normal
Vector3 helperVector = Vector3.Cross(
vertices[index].normal,
vertices[index].tangent);
vertices[index].tangent = Vector3.Cross(
helperVector,
vertices[index].normal);
} // for for (int)
#endregion
#region Set vertex buffer
// Set vertex buffer
vertexBuffer = new VertexBuffer(
BaseGame.Device,
typeof(TangentVertex),
vertices.Length,
ResourceUsage.WriteOnly,
ResourceManagementMode.Automatic);
vertexBuffer.SetData(vertices);
#endregion
#region Calc index buffer
// Calc index buffer (Note: have to use uint, ushort is not sufficiant
// in our case because we have MANY vertices ^^)
uint[] indices = new uint[(GridWidth - 1) * (GridHeight - 1) * 6];
int currentIndex = 0;
for (int x = 0; x < GridWidth - 1; x++)
for (int y = 0; y < GridHeight - 1; y++)
{
// Set landscape data (Note: Right handed)
indices[currentIndex + 0] = (uint)(x * GridHeight + y);
indices[currentIndex + 2] =
(uint)((x + 1) * GridHeight + (y + 1));
indices[currentIndex + 1] = (uint)((x + 1) * GridHeight + y);
indices[currentIndex + 3] =
(uint)((x + 1) * GridHeight + (y + 1));
indices[currentIndex + 5] = (uint)(x * GridHeight + y);
indices[currentIndex + 4] = (uint)(x * GridHeight + (y + 1));
// Add indices
currentIndex += 6;
} // for for (int)
#endregion
#region Set index buffer
indexBuffer = new IndexBuffer(
BaseGame.Device,
typeof(uint),
(GridWidth - 1) * (GridHeight - 1) * 6,
ResourceUsage.WriteOnly,
ResourceManagementMode.Automatic);
indexBuffer.SetData(indices);
#endregion
#region Load track (and replay inside ReloadLevel method)
ReloadLevel();
#endregion
#region Add city planes
// Just set one giant plane for the whole city!
foreach (LandscapeObject obj in landscapeObjects)
if (obj.IsBigBuilding)
{
cityPlane = new PlaneRenderer(
obj.Position,
new Plane(new Vector3(0, 0, 1), 0.1f),
cityMat, Math.Min(obj.Position.X, obj.Position.Y));//);
break;
} // foreach if (obj.IsBigBuilding)
#endregion
}