§12.3赛道

public static void TestRenderingTrack()

{

TrackLine testTrack = new TrackLine( new Vector3[] { new Vector3(20, -20, 0), new Vector3(20, 20, 0), new Vector3(-20, 20, 0), new Vector3(-20, -20, 0),

}

);

TestGame.Start(

delegate

{

ShowGroundGrid();

ShowTrackLines(testTrack);

ShowUpVectors(testTrack);

}

);

} // TestRenderingTrack()

public static void ShowTrackLines(TrackLine track)

{

// Draw the line for each line part

for (int num = 0; num < track.points.Count; num++)

BaseGame.DrawLine( track.points[num].pos, track.points[(num + 1)%track.points.Count].pos, Color.White);

} // ShowTrackLines(track)

public static void TestRenderingTrack()

{

TrackLine testTrack = new TrackLine( new Vector3[] { new Vector3(0, 0, 0), new Vector3(0, 7, 3), new Vector3(0, 10, 10), new Vector3(0, 7, 17), new Vector3(0, 0, 20), new Vector3(0, -7, 17), new Vector3(0, -10, 10), new Vector3(0, -7, 3),

}

); // [Rest stays the same]

} // TestRenderingTrack()

// Generate all points with help of catmull rom splines

for (int num = 0; num < inputPoints.Length; num++)

{

// Get the 4 required points for the catmull rom spline

Vector3 p1 = inputPoints[num-1 < 0 ? inputPoints.Length-1 : num-1];

Vector3 p2 = inputPoints[num];

Vector3 p3 = inputPoints[(num + 1) % inputPoints.Length];

Vector3 p4 = inputPoints[(num + 2) % inputPoints.Length];

// Calculate number of iterations we use here based

// on the distance of the 2 points we generate new points from. float distance = Vector3.Distance(p2, p3);

int numberOfIterations = (int)(NumberOfIterationsPer100Meters * (distance / 100.0f));

if (numberOfIterations <= 0)

numberOfIterations = 1;

Vector3 lastPos = p1;

for (int iter = 0; iter < numberOfIterations; iter++)

{

TrackVertex newVertex = new TrackVertex( Vector3.CatmullRom(p1, p2, p3, p4, iter / (float)numberOfIterations));

points.Add(newVertex);

} // for (iter)

} // for (num)

public ColladaTrack(string setFilename) : base(setFilename)

{

// Get spline first (only use one line)

XmlNode geometry = XmlHelper.GetChildNode(colladaFile, "geometry");

XmlNode visualScene = XmlHelper.GetChildNode(colladaFile, "visual_scene");

string splineId = XmlHelper.GetXmlAttribute(geometry, "id");

// Make sure this is a spline, everything else is not supported.

if (splineId.EndsWith("-spline") == false)

throw new Exception("The ColladaTrack file " + Filename + " does not have a spline geometry in it. Unable to load " + "track!");

// Get spline points XmlNode pointsArray = XmlHelper.GetChildNode(geometry, "float_array");

// Convert the points to a float array float[] pointsValues = StringHelper.ConvertStringToFloatArray( pointsArray.FirstChild.Value);

// Skip first and third of each input point (MAX tangent data)

trackPoints.Clear();

int pointNum = 0;

while (pointNum < pointsValues.Length) {

// Skip first point (first 3 floating point values) pointNum += 3;

// Take second vector trackPoints.Add(MaxScalingFactor * new Vector3( pointsValues[pointNum++], pointsValues[pointNum++], pointsValues[pointNum++]));

// And skip thrid

pointNum += 3;

}

// while (pointNum)

// Check if we can find translation or scaling values for our

// spline XmlNode

splineInstance = XmlHelper.GetChildNode( visualScene, "url", "#" + splineId);

XmlNode splineMatrixNode = XmlHelper.GetChildNode( splineInstance.ParentNode, "matrix");

if (splineMatrixNode != null)

throw new Exception("The ColladaTrack file " + Filename + " should not use baked matrices. Please export again " + "without baking matrices. Unable to load track!");

XmlNode splineTranslateNode = XmlHelper.GetChildNode( splineInstance.ParentNode, "translate");

XmlNode splineScaleNode = XmlHelper.GetChildNode( splineInstance.ParentNode, "scale");

Vector3 splineTranslate = Vector3.Zero;

if (splineTranslateNode != null)

{

float[] translateValues = StringHelper.ConvertStringToFloatArray( splineTranslateNode.FirstChild.Value);

splineTranslate = MaxScalingFactor * new Vector3( translateValues[0], translateValues[1], translateValues[2]);

}

// if (splineTranslateNode)

Vector3 splineScale = new Vector3(1, 1, 1);

if (splineScaleNode != null)

{

float[] scaleValues = StringHelper.ConvertStringToFloatArray( splineScaleNode.FirstChild.Value);

splineScale = new Vector3( scaleValues[0], scaleValues[1], scaleValues[2]);

}

// if (splineTranslateNode)

// Convert all points with our translation and scaling values

for (int num = 0; num < trackPoints.Count; num++)

{

trackPoints[num] = Vector3.Transform(trackPoints[num], Matrix.CreateScale(splineScale) * Matrix.CreateTranslation(splineTranslate));

}

// for (num)

// [Now Helpers are loaded here, the loading code is similar]

} // ColladaTrack(setFilename)

public static void TestRenderTrack()

{

Track track = null;

TestGame.Start( delegate

{ track = new Track("TrackBeginner", null);

},

delegate

{

ShowUpVectors(track); track.Render();

}

);

} // TestRenderingTrack()

public void Render()

{

// We use tangent vertices for everything here

BaseGame.Device.VertexDeclaration = TangentVertex.VertexDeclaration;

// Restore the world matrix

BaseGame.WorldMatrix = Matrix.Identity;

// Render the road itself

ShaderEffect.normalMapping.Render( roadMaterial, "Specular20",

delegate {

BaseGame.Device.Vertices[0].SetSource(roadVb, 0, TangentVertex.SizeInBytes);

BaseGame.Device.Indices = roadIb;

BaseGame.Device.DrawIndexedPrimitives( PrimitiveType.TriangleList, 0, 0, points.Count * 5, 0, (points.Count - 1) * 8);

}

); // [etc. Render rest of road materials]

} // Render()

private void GenerateVerticesAndObjects(Landscape landscape)

{

#region Generate the road vertices

// Each road segment gets 5 points:

// left, left middle, middle, right middle, right.

// The reason for this is that we would have bad triangle errors if the

// road gets wider and wider. This happens because we need to render

// quads, but we can only render triangles, which often have different

// orientations, which makes the road very bumpy. This still happens

// with 8 polygons instead of 2, but it is much better this way.

// Another trick is to not do so many iterations in TrackLine, which

// causes this problem. Better to have a not so round track, but at

// least the road up/down itself is smooth.

// The last point is duplicated (see TrackLine) because we have 2 sets

// of texture coordinates for it (begin block, end block).

// So for the index buffer we only use points.Count-1

blocks. roadVertices = new TangentVertex[points.Count * 5];

// Current texture coordinate for the roadway (in direction of

// movement)

for (int num = 0; num < points.Count; num++)

{ // Get vertices with the help of the properties in the TrackVertex

// class. For the road itself we only need vertices for the left

// and right side, which are vertex number 0 and 1.

roadVertices[num * 5 + 0] = points[num].RightTangentVertex;

roadVertices[num * 5 + 1] = points[num].MiddleRightTangentVertex;

roadVertices[num * 5 + 2] = points[num].MiddleTangentVertex;

roadVertices[num * 5 + 3] = points[num].MiddleLeftTangentVertex;

roadVertices[num * 5 + 4] = points[num].LeftTangentVertex;

} // for (num)

roadVb = new VertexBuffer( BaseGame.Device, typeof(TangentVertex), roadVertices.Length, ResourceUsage.WriteOnly, ResourceManagementMode.Automatic);

roadVb.SetData(roadVertices);

// Also calculate all indices, we have 8 polygons for each segment

// with 3 vertices each. We have 1 segment less than points because

// the last point is duplicated (different tex coords).

int[] indices = new int[(points.Count - 1) * 8 * 3];

int vertexIndex = 0;

for (int num = 0; num < points.Count - 1; num++)

{ // We only use 3 vertices (and the next 3 vertices),

// but we have to construct all 24 indices for our 4 polygons.

for (int sideNum = 0; sideNum < 4; sideNum++)

{

// Each side needs 2 polygons.

// 1. Polygon

indices[num * 24 + 6 * sideNum + 0] = vertexIndex + sideNum;

indices[num * 24 + 6 * sideNum + 1] = vertexIndex + 5 + 1 + sideNum;

indices[num * 24 + 6 * sideNum + 2] = vertexIndex + 5 + sideNum;

// 2. Polygon

indices[num * 24 + 6 * sideNum + 3] = vertexIndex + 5 + 1 + sideNum;

indices[num * 24 + 6 * sideNum + 4] = vertexIndex + sideNum;

indices[num * 24 + 6 * sideNum + 5] = vertexIndex + 1 + sideNum;

} // for (num)

// Go to the next 5 vertices

vertexIndex += 5;

} // for (num)

// Set road back index buffer

roadIb = new IndexBuffer( BaseGame.Device, typeof(int), indices.Length, ResourceUsage.WriteOnly, ResourceManagementMode.Automatic);

roadIb.SetData(indices);

#endregion

// [Then the rest of the road back, tunnel, etc. vertices are

// generated here and all the landscape objects, checkpoints, palms,

// etc. are generated at the end of this method]

} // GenerateVerticesAndObjects(landscape)