3D系列4.16 在指定区域放置树木
本章我们要添加许多树。要获得最好的结果， 我们要在地形上添加一些树林而不是随机放置。
本章要处理的主要问题是：如何创建这些树林的边界？解决方法是使用一张噪点贴图。本系列的最后一章中，你会学习如何自己创建噪点贴图。本章使用的噪点贴图如下所示：
解决方法很简单：如果噪点贴图上的像素的白色值大于某个临界值，我们就会在地形上添加一棵树。因此首先将treeMap.jpg导入到项目中。
然后，看一下GenerateTreePositions方法并做适当变化。第一个变化是方法定义，我们需要将噪点贴图作为参数：
private List<Vector3> GenerateTreePositions(Texture2D treeMap, VertexMultitextured[] terrainVertices)
方法内部的代码变化如下所示：
Color[] treeMapColors = new Color[treeMap.Width * treeMap.Height];
treeMap.GetData(treeMapColors);
int[,] noiseData = new int[treeMap.Width, treeMap.Height];
for (int x = 0; x < treeMap.Width; x++)
for (int y = 0; y < treeMap.Height; y++)
noiseData[x, y] = treeMapColors[y + x * treeMap.Height].R;
List<Vector3> treeList = new List<Vector3> ();
Random random = new Random();
for (int x = 0; x < terrainWidth; x++)
{
for (int y = 0; y < terrainLength; y++)
{
//add trees
}
}
return treeList;
首先将图像转换为一个1D的颜色数组：首先创建一个1D数组，然后使用GetData方法将纹理中的数据复制到这个数组中。然后，这个1D数组被重新排列为一个整数2D数组。对每个像素，获取它的红色分量(它的值介于0和255之间)。因为当前噪点贴图是一张灰度图，所以红色通道的值与绿色和蓝色通道是相同的。
准备好2D数组后，我们创建一个Vector3集合，它也是这个方法的返回值，还有一个随机函数生成器用来使树木不会排成一行。
最后的两个循环遍历地形网格，对每个顶点，我们判断是否需要放置树木，所以需要进行以下检测：
- 高度合适吗？我们不想再在河中央或山顶放置树木。
- 地形平吗？我们不想在峭壁上放置树木。
- 树木的密度如何？我们想在树林中间放置许多树木，而树林边缘的树木密度小。
让我们一个接一个解决上面的问题。
第一个问题很简单：我们只需获取当前位置的高度，检查它是否在可接受的范围之内。所以在循环中用下面的代码替换掉注释：
float terrainHeight = heightData[x, y];
if ((terrainHeight > 8) && (terrainHeight < 14)) { }
这会让树木只放置在地形高度为8至14之间的位置。然后是地形的坡度。我们可以添加一些复杂的算法检测邻近顶点的高度，但事实上我们有更好的东西：每个顶点的法线。法线表示每个顶点垂直于地形的方向。所以在水平的地面上，法线是向上的。这就是我们想要检测的：法线与UP向量靠得有多近，这可以通过点乘这两个向量获得。所以在if-check中放置以下代码：
float flatness = Vector3.Dot(terrainVertices[x + y * terrainWidth].Normal, new Vector3(0, 1, 0));
如果顶点的法线和(0,1,)
Up向量是相同的，点乘的结果为1。如果两者垂直则为0。因为点乘结果就是两个向量间夹角的余弦值，下面的代码可以检测地形的坡度不超过15度：
float minFlatness = (float)Math.Cos(MathHelper.ToRadians(15));
if (flatness> minFlatness) { }
15度对应的点乘结果为0.966，所以我们检测地形的坡度是否比它小。最后，我们还需检测噪点贴图是否允许在当前位置放置树木。所以，我们需要采用对应当前位置的噪点贴图上的点。在if-check中添加以下代码：
float relx = (float)x / (float)terrainWidth;
float rely = (float)y / (float)terrainLength;
float noiseValueAtCurrentPosition = noiseData[(int)(relx * treeMap.Width), (int)(rely * treeMap.Height)];
float treeDensity;
if (noiseValueAtCurrentPosition > 200)
treeDensity = 5;
else if (noiseValueAtCurrentPosition > 150)
treeDensity = 4;
else if (noiseValueAtCurrentPosition > 100)
treeDensity = 3;
else treeDensity = 0;
因为我们想让地形的分辨率与噪点贴图的分辨率无关，所以使用相对坐标。Relx和rely的值介于0和1之间，让我们可以在正确的位置采样噪点贴图。当前位置的噪点值存储在noiseValueAtCurrentPosition变量中，这个变量的值介于0和255之间。
从这个值我们可以决定当前位置应该添加多少树木。如果这个值很大，说明在树林中间，在这个地形顶点周围添加5棵树！这个数量对应当前的噪点值，当噪点值小于某个临界值时树木数量为0。
这样，我们就可以确实知道当前地形顶点上应该放置多少树木。下面的代码生成新树木的位置：
for (int currDetail = 0; currDetail < treeDensity; currDetail++)
{
float rand1 = (float)random.Next(1000) / 1000.0f;
float rand2 = (float)random.Next(1000) / 1000.0f;
Vector3 treePos = new Vector3((float)x - rand1, 0, -(float)y - rand2);
treePos.Y = heightData[x, y]; treeList.Add(treePos);
}
首先生成两个随机数，并缩放到[0,1]区间，使用这两个随机数添加当前顶点的X和Z坐标，使用地形高度作为Y坐标。最后，将新位置添加到集合中。
在LoadVertices方法中，我们还需要加载treeMap.jpg纹理，将它传递到GenerateTreePositions方法！所以，使用以下代码替换掉LoadVertices方法底部的代码：
Texture2D treeMap = Content.Load<Texture2D> ("treeMap");
List<Vector3> treeList = GenerateTreePositions(treeMap, terrainVertices);
CreateBillboardVerticesFromList(treeList);
好了，CreateBillboardVerticesFromList和DrawBillboard方法前面已经定义了，绘制树木的两个三角形是定义在GenerateTreePositions方法中的。现在运行代码！程序截图如下。如果移动相机，你会发现两个缺陷：
- 当你站在山顶看树木时你会看到最主要的缺陷，这个错误也是下一章的主要内容。
- 树木并不会被水面反射！
这个因为没有在DrawReflectionMap方法中绘制树木，所以，在调用DrawSkyDome方法之后，添加以下调用：
DrawBillboards(reflectionViewMatrix);
这样你就可以看到水面上树木的反射了。
本章只有XNA代码有变化，红色代码为相对于上一章改变的部分：
using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Net;
using Microsoft.Xna.Framework.Storage;
namespace XNAseries4
...{
public struct VertexMultitextured
...{
public Vector3 Position;
public Vector3 Normal;
public Vector4 TextureCoordinate;
public Vector4 TexWeights;
public static int SizeInBytes = (3 + 3 + 4 + 4) * sizeof(float);
public static VertexElement[] VertexElements = new VertexElement[]
...{
new VertexElement( 0, 0, VertexElementFormat.Vector3, VertexElementMethod.Default, VertexElementUsage.Position, 0 ),
new VertexElement( 0, sizeof(float) * 3, VertexElementFormat.Vector3, VertexElementMethod.Default, VertexElementUsage.Normal, 0 ),
new VertexElement( 0, sizeof(float) * 6, VertexElementFormat.Vector4, VertexElementMethod.Default, VertexElementUsage.TextureCoordinate, 0 ),
new VertexElement( 0, sizeof(float) * 10, VertexElementFormat.Vector4, VertexElementMethod.Default, VertexElementUsage.TextureCoordinate, 1 ),
};
}
public class Game1 : Microsoft.Xna.Framework.Game
...{
GraphicsDeviceManager graphics;
GraphicsDevice device;
int terrainWidth;
int terrainLength;
float[,] heightData;
VertexBuffer terrainVertexBuffer;
IndexBuffer terrainIndexBuffer;
VertexDeclaration terrainVertexDeclaration;
VertexBuffer waterVertexBuffer;
VertexDeclaration waterVertexDeclaration;
VertexBuffer treeVertexBuffer;
VertexDeclaration treeVertexDeclaration;
Effect effect;
Effect bbEffect;
Matrix viewMatrix;
Matrix projectionMatrix;
Matrix reflectionViewMatrix;
Vector3 cameraPosition = new Vector3(130, 30, -50);
float leftrightRot = MathHelper.PiOver2;
float updownRot = -MathHelper.Pi / 10.0f;
const float rotationSpeed = 0.3f;
const float moveSpeed = 30.0f;
MouseState originalMouseState;
Texture2D grassTexture;
Texture2D sandTexture;
Texture2D rockTexture;
Texture2D snowTexture;
Texture2D cloudMap;
Texture2D waterBumpMap;
Texture2D treeTexture;
Texture2D treeMap;
Model skyDome;
const float waterHeight = 5.0f;
RenderTarget2D refractionRenderTarget;
Texture2D refractionMap;
RenderTarget2D reflectionRenderTarget;
Texture2D reflectionMap;
Vector3 windDirection = new Vector3(0, 0, 1);
public Game1()
...{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
}
protected override void Initialize()
...{
graphics.PreferredBackBufferWidth = 500;
graphics.PreferredBackBufferHeight = 500;
graphics.ApplyChanges();
Window.Title = "Riemer's XNA Tutorials -- Series 4";
base.Initialize();
}
protected override void LoadContent()
...{
device = GraphicsDevice;
effect = Content.Load<Effect> ("Series4Effects");
bbEffect = Content.Load<Effect> ("bbEffect"); UpdateViewMatrix();
projectionMatrix = Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4, device.Viewport.AspectRatio, 0.3f, 1000.0f);
Mouse.SetPosition(device.Viewport.Width / 2, device.Viewport.Height / 2);
originalMouseState = Mouse.GetState();
skyDome = Content.Load<Model> ("dome"); skyDome.Meshes[0].MeshParts[0].Effect = effect.Clone(device);
PresentationParameters pp = device.PresentationParameters;
refractionRenderTarget = new RenderTarget2D(device, pp.BackBufferWidth, pp.BackBufferHeight, 1, device.DisplayMode.Format);
reflectionRenderTarget = new RenderTarget2D(device, pp.BackBufferWidth, pp.BackBufferHeight, 1, device.DisplayMode.Format);
LoadVertices();
LoadTextures();
}
private void LoadVertices()
...{
Texture2D heightMap = Content.Load<Texture2D> ("heightmap"); LoadHeightData(heightMap);
VertexMultitextured[] terrainVertices = SetUpTerrainVertices();
int[] terrainIndices = SetUpTerrainIndices();
terrainVertices = CalculateNormals(terrainVertices, terrainIndices);
CopyToTerrainBuffers(terrainVertices, terrainIndices);
terrainVertexDeclaration = new VertexDeclaration(device, VertexMultitextured.VertexElements);
SetUpWaterVertices();
waterVertexDeclaration = new VertexDeclaration(device, VertexPositionTexture.VertexElements);
Texture2D treeMap = Content.Load<Texture2D> ("treeMap");
List<Vector3> treeList = GenerateTreePositions(treeMap, terrainVertices); CreateBillboardVerticesFromList(treeList);
}
private void LoadTextures()
...{
grassTexture = Content.Load<Texture2D> ("grass");
sandTexture = Content.Load<Texture2D> ("sand");
rockTexture = Content.Load<Texture2D> ("rock");
snowTexture = Content.Load<Texture2D> ("snow");
cloudMap = Content.Load<Texture2D> ("cloudMap");
waterBumpMap = Content.Load<Texture2D> ("waterbump");
treeTexture = Content.Load<Texture2D> ("tree");
treeMap = Content.Load<Texture2D> ("treeMap"); }
private void LoadHeightData(Texture2D heightMap)
...{
float minimumHeight = float.MaxValue;
float maximumHeight = float.MinValue;
terrainWidth = heightMap.Width;
terrainLength = heightMap.Height;
Color[] heightMapColors = new Color[terrainWidth * terrainLength];
heightMap.GetData(heightMapColors);
heightData = new float[terrainWidth, terrainLength];
for (int x = 0; x < terrainWidth; x++)
for (int y = 0; y < terrainLength; y++)
...{
heightData[x, y] = heightMapColors[x + y * terrainWidth].R;
if (heightData[x, y] < minimumHeight) minimumHeight = heightData[x, y];
if (heightData[x, y] > maximumHeight) maximumHeight = heightData[x, y];
}
for (int x = 0; x < terrainWidth; x++)
for (int y = 0; y < terrainLength; y++)
heightData[x, y] = (heightData[x, y] - minimumHeight) / (maximumHeight - minimumHeight) * 30.0f;
}
private VertexMultitextured[] SetUpTerrainVertices()
...{
VertexMultitextured[] terrainVertices = new VertexMultitextured[terrainWidth * terrainLength];
for (int x = 0; x < terrainWidth; x++)
...{
for (int y = 0; y < terrainLength; y++)
...{
terrainVertices[x + y * terrainWidth].Position = new Vector3(x, heightData[x, y], -y);
terrainVertices[x + y * terrainWidth].TextureCoordinate.X = (float)x / 30.0f;
terrainVertices[x + y * terrainWidth].TextureCoordinate.Y = (float)y / 30.0f;
terrainVertices[x + y * terrainWidth].TexWeights.X = MathHelper.Clamp(1.0f - Math.Abs(heightData[x, y] - 0) / 8.0f, 0, 1);
terrainVertices[x + y * terrainWidth].TexWeights.Y = MathHelper.Clamp(1.0f - Math.Abs(heightData[x, y] - 12) / 6.0f, 0, 1);
terrainVertices[x + y * terrainWidth].TexWeights.Z = MathHelper.Clamp(1.0f - Math.Abs(heightData[x, y] - 20) / 6.0f, 0, 1);
terrainVertices[x + y * terrainWidth].TexWeights.W = MathHelper.Clamp(1.0f - Math.Abs(heightData[x, y] - 30) / 6.0f, 0, 1);
float total = terrainVertices[x + y * terrainWidth].TexWeights.X;
total += terrainVertices[x + y * terrainWidth].TexWeights.Y;
total += terrainVertices[x + y * terrainWidth].TexWeights.Z;
total += terrainVertices[x + y * terrainWidth].TexWeights.W;
terrainVertices[x + y * terrainWidth].TexWeights.X /= total;
terrainVertices[x + y * terrainWidth].TexWeights.Y /= total;
terrainVertices[x + y * terrainWidth].TexWeights.Z /= total;
terrainVertices[x + y * terrainWidth].TexWeights.W /= total;
}
}
return terrainVertices;
}
private int[] SetUpTerrainIndices()
...{
int[] indices = new int[(terrainWidth - 1) * (terrainLength - 1) * 6];
int counter = 0;
for (int y = 0; y < terrainLength - 1; y++)
...{
for (int x = 0; x < terrainWidth - 1; x++)
...{
int lowerLeft = x + y * terrainWidth;
int lowerRight = (x + 1) + y * terrainWidth;
int topLeft = x + (y + 1) * terrainWidth;
int topRight = (x + 1) + (y + 1) * terrainWidth;
indices[counter++] = topLeft;
indices[counter++] = lowerRight;
indices[counter++] = lowerLeft;
indices[counter++] = topLeft;
indices[counter++] = topRight;
indices[counter++] = lowerRight;
}
}
return indices;
}
private VertexMultitextured[] CalculateNormals(VertexMultitextured[] vertices, int[] indices)
...{
for (int i = 0; i < vertices.Length; i++)
vertices[i].Normal = new Vector3(0, 0, 0);
for (int i = 0; i < indices.Length / 3; i++)
...{
int index1 = indices[i * 3];
int index2 = indices[i * 3 + 1];
int index3 = indices[i * 3 + 2];
Vector3 side1 = vertices[index1].Position - vertices[index3].Position;
Vector3 side2 = vertices[index1].Position - vertices[index2].Position;
Vector3 normal = Vector3.Cross(side1, side2);
vertices[index1].Normal += normal;
vertices[index2].Normal += normal;
vertices[index3].Normal += normal;
}
for (int i = 0; i < vertices.Length; i++)
vertices[i].Normal.Normalize();
return vertices;
}
private void CopyToTerrainBuffers(VertexMultitextured[] vertices, int[] indices)
...{
terrainVertexBuffer = new VertexBuffer(device, vertices.Length * VertexMultitextured.SizeInBytes, BufferUsage.WriteOnly);
terrainVertexBuffer.SetData(vertices);
terrainIndexBuffer = new IndexBuffer(device, typeof(int), indices.Length, BufferUsage.WriteOnly);
terrainIndexBuffer.SetData(indices);
}
private void SetUpWaterVertices()
...{
VertexPositionTexture[] waterVertices = new VertexPositionTexture[6];
waterVertices[0] = new VertexPositionTexture(new Vector3(0, waterHeight, 0), new Vector2(0, 1));
waterVertices[2] = new VertexPositionTexture(new Vector3(terrainWidth, waterHeight, -terrainLength), new Vector2(1, 0));
waterVertices[1] = new VertexPositionTexture(new Vector3(0, waterHeight, -terrainLength), new Vector2(0, 0));
waterVertices[3] = new VertexPositionTexture(new Vector3(0, waterHeight, 0), new Vector2(0, 1));
waterVertices[5] = new VertexPositionTexture(new Vector3(terrainWidth, waterHeight, 0), new Vector2(1, 1));
waterVertices[4] = new VertexPositionTexture(new Vector3(terrainWidth, waterHeight, -terrainLength), new Vector2(1, 0));
waterVertexBuffer = new VertexBuffer(device, waterVertices.Length * VertexPositionTexture.SizeInBytes, BufferUsage.WriteOnly);
waterVertexBuffer.SetData(waterVertices);
}
private void CreateBillboardVerticesFromList(List<Vector3> treeList) ...{
VertexPositionTexture[] billboardVertices = new VertexPositionTexture[treeList.Count * 6];
int i = 0;
foreach (Vector3 currentV3 in treeList)
...{
billboardVertices[i++] = new VertexPositionTexture(currentV3, new Vector2(0, 0));
billboardVertices[i++] = new VertexPositionTexture(currentV3, new Vector2(1, 0));
billboardVertices[i++] = new VertexPositionTexture(currentV3, new Vector2(1, 1));
billboardVertices[i++] = new VertexPositionTexture(currentV3, new Vector2(0, 0));
billboardVertices[i++] = new VertexPositionTexture(currentV3, new Vector2(1, 1));
billboardVertices[i++] = new VertexPositionTexture(currentV3, new Vector2(0, 1));
}
treeVertexBuffer = new VertexBuffer(device, billboardVertices.Length * VertexPositionTexture.SizeInBytes, BufferUsage.WriteOnly);
treeVertexBuffer.SetData(billboardVertices);
treeVertexDeclaration = new VertexDeclaration(device, VertexPositionTexture.VertexElements);
}
private List<Vector3> GenerateTreePositions(Texture2D treeMap, VertexMultitextured[] terrainVertices) ...{
Color[] treeMapColors = new Color[treeMap.Width * treeMap.Height];
treeMap.GetData(treeMapColors);
int[,] noiseData = new int[treeMap.Width, treeMap.Height];
for (int x = 0; x < treeMap.Width; x++)
for (int y = 0; y < treeMap.Height; y++)
noiseData[x, y] = treeMapColors[y + x * treeMap.Height].R;
List<Vector3> treeList = new List<Vector3> (); Random random = new Random();
for (int x = 0; x < terrainWidth; x++)
...{
for (int y = 0; y < terrainLength; y++)
...{
float terrainHeight = heightData[x, y];
if ((terrainHeight > 8) && (terrainHeight < 14))
...{
float flatness = Vector3.Dot(terrainVertices[x + y * terrainWidth].Normal, new Vector3(0, 1, 0));
float minFlatness = (float)Math.Cos(MathHelper.ToRadians(15));
if (flatness > minFlatness)
...{
float relx = (float)x / (float)terrainWidth;
float rely = (float)y / (float)terrainLength;
float noiseValueAtCurrentPosition = noiseData[(int)(relx * treeMap.Width), (int)(rely * treeMap.Height)];
float treeDensity;
if (noiseValueAtCurrentPosition > 200)
treeDensity = 5;
else if (noiseValueAtCurrentPosition > 150)
treeDensity = 4;
else if (noiseValueAtCurrentPosition > 100)
treeDensity = 3;
else
treeDensity = 0;
for (int currDetail = 0; currDetail < treeDensity; currDetail++)
...{
float rand1 = (float)random.Next(1000) / 1000.0f;
float rand2 = (float)random.Next(1000) / 1000.0f;
Vector3 treePos = new Vector3((float)x - rand1, 0, -(float)y - rand2);
treePos.Y = heightData[x, y];
treeList.Add(treePos);
}
}
}
}
}
return treeList;
}
protected override void UnloadContent()
...{
}
protected override void Update(GameTime gameTime)
...{
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
this.Exit();
float timeDifference = (float)gameTime.ElapsedGameTime.TotalMilliseconds / 1000.0f;
ProcessInput(timeDifference);
base.Update(gameTime);
}
private void ProcessInput(float amount)
...{
MouseState currentMouseState = Mouse.GetState();
if (currentMouseState != originalMouseState)
...{
float xDifference = currentMouseState.X - originalMouseState.X;
float yDifference = currentMouseState.Y - originalMouseState.Y;
leftrightRot -= rotationSpeed * xDifference * amount;
updownRot -= rotationSpeed * yDifference * amount;
Mouse.SetPosition(device.Viewport.Width / 2, device.Viewport.Height / 2);
UpdateViewMatrix();
}
Vector3 moveVector = new Vector3(0, 0, 0);
KeyboardState keyState = Keyboard.GetState();
if (keyState.IsKeyDown(Keys.Up) || keyState.IsKeyDown(Keys.W))
moveVector += new Vector3(0, 0, -1);
if (keyState.IsKeyDown(Keys.Down) || keyState.IsKeyDown(Keys.S))
moveVector += new Vector3(0, 0, 1);
if (keyState.IsKeyDown(Keys.Right) || keyState.IsKeyDown(Keys.D))
moveVector += new Vector3(1, 0, 0);
if (keyState.IsKeyDown(Keys.Left) || keyState.IsKeyDown(Keys.A))
moveVector += new Vector3(-1, 0, 0);
if (keyState.IsKeyDown(Keys.Q))
moveVector += new Vector3(0, 1, 0);
if (keyState.IsKeyDown(Keys.Z))
moveVector += new Vector3(0, -1, 0);
AddToCameraPosition(moveVector * amount);
}
private void AddToCameraPosition(Vector3 vectorToAdd)
...{
Matrix cameraRotation = Matrix.CreateRotationX(updownRot) * Matrix.CreateRotationY(leftrightRot);
Vector3 rotatedVector = Vector3.Transform(vectorToAdd, cameraRotation);
cameraPosition += moveSpeed * rotatedVector;
UpdateViewMatrix();
}
private void UpdateViewMatrix()
...{
Matrix cameraRotation = Matrix.CreateRotationX(updownRot) * Matrix.CreateRotationY(leftrightRot);
Vector3 cameraOriginalTarget = new Vector3(0, 0, -1);
Vector3 cameraOriginalUpVector = new Vector3(0, 1, 0);
Vector3 cameraRotatedTarget = Vector3.Transform(cameraOriginalTarget, cameraRotation);
Vector3 cameraFinalTarget = cameraPosition + cameraRotatedTarget;
Vector3 cameraRotatedUpVector = Vector3.Transform(cameraOriginalUpVector, cameraRotation);
viewMatrix = Matrix.CreateLookAt(cameraPosition, cameraFinalTarget, cameraRotatedUpVector);
Vector3 reflCameraPosition = cameraPosition;
reflCameraPosition.Y = -cameraPosition.Y + waterHeight * 2;
Vector3 reflTargetPos = cameraFinalTarget;
reflTargetPos.Y = -cameraFinalTarget.Y + waterHeight * 2;
Vector3 cameraRight = Vector3.Transform(new Vector3(1, 0, 0), cameraRotation);
Vector3 invUpVector = Vector3.Cross(cameraRight, reflTargetPos - reflCameraPosition);
reflectionViewMatrix = Matrix.CreateLookAt(reflCameraPosition, reflTargetPos, invUpVector);
}
protected override void Draw(GameTime gameTime)
...{
float time = (float)gameTime.TotalGameTime.TotalMilliseconds / 100.0f;
DrawRefractionMap();
DrawReflectionMap();
device.Clear(ClearOptions.Target | ClearOptions.DepthBuffer, Color.White, 1.0f, 0);
DrawSkyDome(viewMatrix);
DrawTerrain(viewMatrix);
DrawWater(time);
DrawBillboards(viewMatrix);
base.Draw(gameTime);
}
private void DrawTerrain(Matrix currentViewMatrix)
...{
effect.CurrentTechnique = effect.Techniques["MultiTextured"];
effect.Parameters["xTexture0"].SetValue(sandTexture);
effect.Parameters["xTexture1"].SetValue(grassTexture);
effect.Parameters["xTexture2"].SetValue(rockTexture);
effect.Parameters["xTexture3"].SetValue(snowTexture);
Matrix worldMatrix = Matrix.Identity;
effect.Parameters["xWorld"].SetValue(worldMatrix);
effect.Parameters["xView"].SetValue(currentViewMatrix);
effect.Parameters["xProjection"].SetValue(projectionMatrix);
effect.Parameters["xEnableLighting"].SetValue(true);
effect.Parameters["xAmbient"].SetValue(0.4f);
effect.Parameters["xLightDirection"].SetValue(new Vector3(-0.5f, -1, -0.5f));
effect.Begin();
foreach (EffectPass pass in effect.CurrentTechnique.Passes)
...{
pass.Begin();
device.Vertices[0].SetSource(terrainVertexBuffer, 0, VertexMultitextured.SizeInBytes);
device.Indices = terrainIndexBuffer;
device.VertexDeclaration = terrainVertexDeclaration;
int noVertices = terrainVertexBuffer.SizeInBytes / VertexMultitextured.SizeInBytes;
int noTriangles = terrainIndexBuffer.SizeInBytes / sizeof(int) / 3;
device.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, noVertices, 0, noTriangles);
pass.End();
}
effect.End();
}
private void DrawSkyDome(Matrix currentViewMatrix)
...{
device.RenderState.DepthBufferWriteEnable = false;
Matrix[] modelTransforms = new Matrix[skyDome.Bones.Count];
skyDome.CopyAbsoluteBoneTransformsTo(modelTransforms);
Matrix wMatrix = Matrix.CreateTranslation(0, -0.3f, 0) * Matrix.CreateScale(100) * Matrix.CreateTranslation(cameraPosition);
foreach (ModelMesh mesh in skyDome.Meshes)
...{
foreach (Effect currentEffect in mesh.Effects)
...{
Matrix worldMatrix = modelTransforms[mesh.ParentBone.Index] * wMatrix;
currentEffect.CurrentTechnique = currentEffect.Techniques["Textured"];
currentEffect.Parameters["xWorld"].SetValue(worldMatrix);
currentEffect.Parameters["xView"].SetValue(currentViewMatrix);
currentEffect.Parameters["xProjection"].SetValue(projectionMatrix);
currentEffect.Parameters["xTexture"].SetValue(cloudMap);
currentEffect.Parameters["xEnableLighting"].SetValue(false);
}
mesh.Draw();
}
device.RenderState.DepthBufferWriteEnable = true;
}
private Plane CreatePlane(float height, Vector3 planeNormalDirection, Matrix currentViewMatrix, bool clipSide)
...{
planeNormalDirection.Normalize();
Vector4 planeCoeffs = new Vector4(planeNormalDirection, height);
if (clipSide)
planeCoeffs *= -1;
Matrix worldViewProjection = currentViewMatrix * projectionMatrix;
Matrix inverseWorldViewProjection = Matrix.Invert(worldViewProjection);
inverseWorldViewProjection = Matrix.Transpose(inverseWorldViewProjection);
planeCoeffs = Vector4.Transform(planeCoeffs, inverseWorldViewProjection);
Plane finalPlane = new Plane(planeCoeffs);
return finalPlane;
}
private void DrawRefractionMap()
...{
Plane refractionPlane = CreatePlane(waterHeight + 1.5f, new Vector3(0, -1, 0), viewMatrix, false);
device.ClipPlanes[0].Plane = refractionPlane;
device.ClipPlanes[0].IsEnabled = true;
device.SetRenderTarget(0, refractionRenderTarget);
device.Clear(ClearOptions.Target | ClearOptions.DepthBuffer, Color.Black, 1.0f, 0);
DrawTerrain(viewMatrix);
device.ClipPlanes[0].IsEnabled = false;
device.SetRenderTarget(0, null);
refractionMap = refractionRenderTarget.GetTexture();
}
private void DrawReflectionMap()
...{
Plane reflectionPlane = CreatePlane(waterHeight - 0.5f, new Vector3(0, -1, 0), reflectionViewMatrix, true);
device.ClipPlanes[0].Plane = reflectionPlane;
device.ClipPlanes[0].IsEnabled = true;
device.SetRenderTarget(0, reflectionRenderTarget);
device.Clear(ClearOptions.Target | ClearOptions.DepthBuffer, Color.Black, 1.0f, 0);
DrawSkyDome(reflectionViewMatrix);
DrawTerrain(reflectionViewMatrix);
DrawBillboards(reflectionViewMatrix);
device.ClipPlanes[0].IsEnabled = false;
device.SetRenderTarget(0, null);
reflectionMap = reflectionRenderTarget.GetTexture();
}
private void DrawWater(float time)
...{
effect.CurrentTechnique = effect.Techniques["Water"];
Matrix worldMatrix = Matrix.Identity;
effect.Parameters["xWorld"].SetValue(worldMatrix);
effect.Parameters["xView"].SetValue(viewMatrix);
effect.Parameters["xReflectionView"].SetValue(reflectionViewMatrix);
effect.Parameters["xProjection"].SetValue(projectionMatrix);
effect.Parameters["xReflectionMap"].SetValue(reflectionMap);
effect.Parameters["xRefractionMap"].SetValue(refractionMap);
effect.Parameters["xWaterBumpMap"].SetValue(waterBumpMap);
effect.Parameters["xWaveLength"].SetValue(0.1f);
effect.Parameters["xWaveHeight"].SetValue(0.3f);
effect.Parameters["xCamPos"].SetValue(cameraPosition);
effect.Parameters["xTime"].SetValue(time);
effect.Parameters["xWindForce"].SetValue(0.002f);
effect.Parameters["xWindDirection"].SetValue(windDirection);
effect.Begin();
foreach (EffectPass pass in effect.CurrentTechnique.Passes)
...{
pass.Begin();
device.Vertices[0].SetSource(waterVertexBuffer, 0, VertexPositionTexture.SizeInBytes);
device.VertexDeclaration = waterVertexDeclaration;
int noVertices = waterVertexBuffer.SizeInBytes / VertexPositionTexture.SizeInBytes;
device.DrawPrimitives(PrimitiveType.TriangleList, 0, noVertices / 3);
pass.End();
}
effect.End();
}
private void DrawBillboards(Matrix currentViewMatrix)
...{
bbEffect.CurrentTechnique = bbEffect.Techniques["CylBillboard"];
bbEffect.Parameters["xWorld"].SetValue(Matrix.Identity);
bbEffect.Parameters["xView"].SetValue(currentViewMatrix);
bbEffect.Parameters["xProjection"].SetValue(projectionMatrix);
bbEffect.Parameters["xCamPos"].SetValue(cameraPosition);
bbEffect.Parameters["xAllowedRotDir"].SetValue(new Vector3(0, 1, 0));
bbEffect.Parameters["xBillboardTexture"].SetValue(treeTexture);
device.RenderState.AlphaBlendEnable = true;
device.RenderState.SourceBlend = Blend.SourceAlpha;
device.RenderState.DestinationBlend = Blend.InverseSourceAlpha;
bbEffect.Begin();
foreach (EffectPass pass in bbEffect.CurrentTechnique.Passes)
...{
pass.Begin();
device.Vertices[0].SetSource(treeVertexBuffer, 0, VertexPositionTexture.SizeInBytes);
device.VertexDeclaration = treeVertexDeclaration;
int noVertices = treeVertexBuffer.SizeInBytes / VertexPositionTexture.SizeInBytes;
int noTriangles = noVertices / 3;
device.DrawPrimitives(PrimitiveType.TriangleList, 0, noTriangles);
pass.End();
}
bbEffect.End();
device.RenderState.AlphaBlendEnable = false;
}
}
}
发布时间：2009/12/31 下午12:43:31 阅读次数：8097
