| Topic: XNA 4.0 conversion
|
|
 | XNA 4.0 conversion | |  |
| Poster | : Yagir1 | | Posts | : 2 | | Country | : US | | City | : Boondies |
| | | | Posted by Yagir1 on 29/06/2011 at 11:55:44
| | Hello there Riemer community. Hehe. I just wanted to say this site is amazing with its tutorials. I've been working through this tut and ran into conversion problems as I'm sure most of you have too. since this is my first post please give me a bit of slack on format lol. But anyway, here's what I came up with for the 4.0 conversion, if I did anything wrong, please let me know!! Thanks, here it is.
using System;
using System.Collections.Generic;
using System.Linq;
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.Media;
namespace XNASeries4
{
public struct VertexPositionNormalTexture
{
public Vector3 Position;
public Color Color;
public Vector3 Normal;
public static int SizeInBytes = 7 * 4;
public readonly static VertexDeclaration VertexDeclaration = new VertexDeclaration
(
new VertexElement(0, VertexElementFormat.Vector3, VertexElementUsage.Position, 0),
new VertexElement(sizeof(float) * 3, VertexElementFormat.Color, VertexElementUsage.Color, 0),
new VertexElement(sizeof(float) * 3 + 4, VertexElementFormat.Vector3, VertexElementUsage.Normal, 0)
);
}
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, VertexElementFormat.Vector3, VertexElementUsage.Position, 0 ),
new VertexElement( sizeof(float) * 3, VertexElementFormat.Vector3, VertexElementUsage.Normal, 0 ),
new VertexElement( sizeof(float) * 6, VertexElementFormat.Vector4, VertexElementUsage.TextureCoordinate, 0 ),
new VertexElement( sizeof(float) * 10, VertexElementFormat.Vector4, VertexElementUsage.TextureCoordinate, 1 ),
};
}
public class Game1 : Microsoft.Xna.Framework.Game
{
GraphicsDeviceManager graphics;
GraphicsDevice device;
int terrainWidth;
int terrainLength;
float[,] heightData;
VertexBuffer terrainVertexBuffer;
IndexBuffer terrainIndexBuffer;
VertexMultitextured[] vertices;
int[] indices;
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.1f;
const float moveSpeed = 30.0f;
MouseState originalMouseState;
Texture2D grassTexture;
Texture2D sandTexture;
Texture2D rockTexture;
Texture2D snowTexture;
Texture2D cloudMap;
Texture2D waterBumpMap;
Texture2D treeTexture;
VertexBuffer treeVertexBuffer;
VertexDeclaration treeVertexDeclaration;
Model skyDome;
const float waterHeight = 5.0f;
RenderTarget2D refractionRenderTarget;
Texture2D refractionMap;
RenderTarget2D reflectionRenderTarget;
Texture2D reflectionMap;
VertexBuffer waterVertexBuffer;
Vector3 windDirection = new Vector3(1, 0, 0);
public Game1()
{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
}
protected override void Initialize()
{
IsMouseVisible = true;
graphics.PreferredBackBufferWidth = 1500;
graphics.PreferredBackBufferHeight = 1000;
graphics.ApplyChanges();
Window.Title = "Riemer's XNA Tutorials -- Series 4";
base.Initialize();
}
protected override void LoadContent()
{
device = GraphicsDevice;
effect = Content.Load<Effect>("Series4Effects");
UpdateViewMatrix();
viewMatrix = Matrix.CreateLookAt(new Vector3(130, 30, -50), new Vector3(0, 0, -40), new Vector3(0, 1, 0));
projectionMatrix = Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4, device.Viewport.AspectRatio, 0.3f, 1000.0f);
skyDome = Content.Load<Model>("dome"); skyDome.Meshes[0].MeshParts[0].Effect = effect.Clone();
PresentationParameters pp = device.PresentationParameters;
refractionRenderTarget = new RenderTarget2D(device, pp.BackBufferWidth, pp.BackBufferHeight, false, pp.BackBufferFormat, pp.DepthStencilFormat);
reflectionRenderTarget = new RenderTarget2D(device, pp.BackBufferWidth, pp.BackBufferHeight, false, pp.BackBufferFormat, pp.DepthStencilFormat);
Mouse.SetPosition(device.Viewport.Width / 2, device.Viewport.Height / 2);
originalMouseState = Mouse.GetState();
bbEffect = Content.Load<Effect>("bbEffect");
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);
List<Vector3> treeList = GenerateTreePositions(terrainVertices);
CreateBillboardVerticesFromList(treeList);
SetUpWaterVertices();
}
private void LoadTextures()
{
grassTexture = Content.Load<Texture2D>("grass");
sandTexture = Content.Load<Texture2D>("sand");
rockTexture = Content.Load<Texture2D>("rock");
snowTexture = Content.Load<Texture2D>("snow");
treeTexture = Content.Load<Texture2D>("tree");
cloudMap = Content.Load<Texture2D>("cloudMap");
waterBumpMap = Content.Load<Texture2D>("waterbump");
}
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];
vertices = 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 List<Vector3> GenerateTreePositions(VertexMultitextured[] terrainVertices)
{
List<Vector3> treeList = new List<Vector3>();
treeList.Add(terrainVertices[3310].Position);
treeList.Add(terrainVertices[3315].Position);
treeList.Add(terrainVertices[3320].Position);
treeList.Add(terrainVertices[3325].Position);
return treeList;
}
private int[] SetUpTerrainIndices()
{
int counter = 0;
indices = new int[(terrainWidth - 1) * (terrainLength - 1) * 6];
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)
{
VertexDeclaration vertexDeclaration = new VertexDeclaration(VertexMultitextured.VertexElements);
terrainVertexBuffer = new VertexBuffer(device, vertexDeclaration, vertices.Length, BufferUsage.WriteOnly);
terrainVertexBuffer.SetData(vertices.ToArray());
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(GraphicsDevice, VertexPositionTexture.VertexDeclaration, waterVertices.Count(), BufferUsage.WriteOnly);
waterVertexBuffer.SetData(waterVertices);
}
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 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));
}
VertexDeclaration vertexDeclaration = VertexPositionTexture.VertexDeclaration;
treeVertexBuffer = new VertexBuffer(device, vertexDeclaration, billboardVertices.Length, BufferUsage.WriteOnly);
treeVertexBuffer.SetData(billboardVertices);
treeVertexDeclaration = vertexDeclaration;
}
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;
RasterizerState rs = new RasterizerState();
rs.CullMode = CullMode.None;
device.RasterizerState = rs;
DrawRefractionMap();
DrawReflectionMap();
device.Clear(ClearOptions.Target | ClearOptions.DepthBuffer, Color.Black, 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));
foreach (EffectPass pass in effect.CurrentTechnique.Passes)
{
pass.Apply();
device.Indices = terrainIndexBuffer;
device.SetVertexBuffer(terrainVertexBuffer);
device.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, vertices.Length, 0, indices.Length / 3);
}
}
private void DrawSkyDome(Matrix currentViewMatrix)
{
GraphicsDevice.DepthStencilState = DepthStencilState.None;
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();
}
GraphicsDevice.BlendState = BlendState.Opaque;
GraphicsDevice.DepthStencilState = DepthStencilState.Default;
}
private Plane CreatePlane(float height, Vector3 planeNormalDirection, Matrix currentViewMatrix, bool clipSide)
{
planeNormalDirection.Normalize();
Vector4 planeCoeffs = new Vector4(planeNormalDirection, height);
if (clipSide) planeCoeffs *= -1;
Plane finalPlane = new Plane(planeCoeffs);
return finalPlane;
}
private void DrawRefractionMap()
{
Plane refractionPlane = CreatePlane(waterHeight + 1.5f, new Vector3(0, -1, 0), viewMatrix, false);
effect.Parameters["ClipPlane0"].SetValue(new Vector4(refractionPlane.Normal, refractionPlane.D));
effect.Parameters["Clipping"].SetValue(true); // Allows the geometry to be clipped for the purpose of creating a refraction map
device.SetRenderTarget(refractionRenderTarget);
device.Clear(ClearOptions.Target | ClearOptions.DepthBuffer, Color.Black, 1.0f, 0);
DrawTerrain(viewMatrix);
device.SetRenderTarget(null);
effect.Parameters["Clipping"].SetValue(false); // Make sure you turn it back off so the whole scene doesnt keep rendering as clipped
refractionMap = refractionRenderTarget;
}
private void DrawReflectionMap()
{
Plane reflectionPlane = CreatePlane(waterHeight - 0.5f, new Vector3(0, -1, 0), reflectionViewMatrix, true);
effect.Parameters["ClipPlane0"].SetValue(new Vector4(reflectionPlane.Normal, reflectionPlane.D));
effect.Parameters["Clipping"].SetValue(true); // Allows the geometry to be clipped for the purpose of creating a refraction map
device.SetRenderTarget(reflectionRenderTarget);
device.Clear(ClearOptions.Target | ClearOptions.DepthBuffer, Color.Black, 1.0f, 0);
DrawSkyDome(reflectionViewMatrix);
DrawTerrain(reflectionViewMatrix);
effect.Parameters["Clipping"].SetValue(false);
device.SetRenderTarget(null);
reflectionMap = reflectionRenderTarget;
}
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["xWaterBumpMap"].SetValue(waterBumpMap);
effect.Parameters["xWaveLength"].SetValue(0.1f);
effect.Parameters["xWaveHeight"].SetValue(0.3f);
effect.Parameters["xTime"].SetValue(time);
effect.Parameters["xWindForce"].SetValue(0.002f);
effect.Parameters["xWindDirection"].SetValue(windDirection);
effect.CurrentTechnique.Passes[0].Apply();
device.SetVertexBuffer(waterVertexBuffer);
device.DrawPrimitives(PrimitiveType.TriangleList, 0, waterVertexBuffer.VertexCount / 3);
}
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.BlendState = BlendState.AlphaBlend;
foreach (EffectPass pass in bbEffect.CurrentTechnique.Passes)
{
pass.Apply();
device.SetVertexBuffer(treeVertexBuffer);
int noVertices = treeVertexBuffer.VertexCount;
int noTriangles = noVertices / 3;
device.DrawPrimitives(PrimitiveType.TriangleList, 0, noTriangles);
}
device.BlendState = BlendState.Opaque;
}
}
} |
| |
|
| | | | | | Poster | : Anonymous | | Posts | : | | Country | : | | City | : |
| | | | Posted by Anonymous on 01/07/2011 at 06:59:45
| | Great stuff - Thanks Yagir1!
I was completly failing to convert the code myself :)
Though, I was wondering, how did you amend the shader to incorporate clippanes? | |
|
| | | | | | Poster | : Yagir1 | | Posts | : 2 | | Country | : US | | City | : Boondies |
| | | | Posted by Yagir1 on 02/07/2011 at 13:50:32
| | Oh, duh, I forgot the HLSL code. I wanted to clip planes inside the fx file so I asked for a Clip Distance from the Multi Textured Vertex Shader (Which is just the dot product of the inPos(Position) and whatever is sent through the Parameter "ClipPlane0" which in my case is the normal to the refractive surface). All that we need from this information is the sign, if the dot product is positive then the angle between the two Vectors is less than 90(or pi / 2), meaning we want to see that portion, however if it is negative that means the angle is greater than 90 (pi / 2) and we want to clip that part. And a dot product equal to zero means they are perpindicular(sp?). Anyway, right before we send that pixel to the frame we check to see if were clipping that model, if we are, call the clip function, sending it the clip distance. This function discards the pixel if the value is less than zero, so essentially, only if we don't need to render it to the screen.
Pretty simple stuff if you understand Vector Manipulation :)
//----------------------------------------------------
//-- --
//-- www.riemers.net --
//-- Series 4: Advanced terrain --
//-- Shader code --
//-- --
//----------------------------------------------------
//------- Constants --------
float4x4 xView;
float4x4 xReflectionView;
float4x4 xProjection;
float4x4 xWorld;
float3 xLightDirection;
float xAmbient;
bool xEnableLighting;
float xWaveLength;
float xWaveHeight;
float3 xCamPos;
float xTime;
float xWindForce;
float3 xWindDirection;
float xOvercast;
bool Clipping;
float4 ClipPlane0;
//------- Texture Samplers --------
Texture xTexture;
sampler TextureSampler = sampler_state { texture = <xTexture> ; magfilter = LINEAR; minfilter = LINEAR; mipfilter=LINEAR; AddressU = mirror; AddressV = mirror;};Texture xTexture0;
sampler TextureSampler0 = sampler_state { texture = <xTexture0> ; magfilter = LINEAR; minfilter = LINEAR; mipfilter=LINEAR; AddressU = wrap; AddressV = wrap;};Texture xTexture1;
sampler TextureSampler1 = sampler_state { texture = <xTexture1> ; magfilter = LINEAR; minfilter = LINEAR; mipfilter=LINEAR; AddressU = wrap; AddressV = wrap;};Texture xTexture2;
sampler TextureSampler2 = sampler_state { texture = <xTexture2> ; magfilter = LINEAR; minfilter = LINEAR; mipfilter=LINEAR; AddressU = mirror; AddressV = mirror;};Texture xTexture3;
sampler TextureSampler3 = sampler_state { texture = <xTexture3> ; magfilter = LINEAR; minfilter = LINEAR; mipfilter=LINEAR; AddressU = mirror; AddressV = mirror;};Texture xReflectionMap;
sampler ReflectionSampler = sampler_state { texture = <xReflectionMap> ; magfilter = LINEAR; minfilter = LINEAR; mipfilter=LINEAR; AddressU = mirror; AddressV = mirror;};Texture xRefractionMap;
sampler RefractionSampler = sampler_state { texture = <xRefractionMap> ; magfilter = LINEAR; minfilter = LINEAR; mipfilter=LINEAR; AddressU = mirror; AddressV = mirror;};Texture xWaterBumpMap;
sampler WaterBumpMapSampler = sampler_state { texture = <xWaterBumpMap> ; magfilter = LINEAR; minfilter = LINEAR; mipfilter=LINEAR; AddressU = mirror; AddressV = mirror;};
//------- Technique: Textured --------
struct TVertexToPixel
{
float4 Position : POSITION;
float4 Color : COLOR0;
float LightingFactor: TEXCOORD0;
float2 TextureCoords: TEXCOORD1;
};
struct TPixelToFrame
{
float4 Color : COLOR0;
};
TVertexToPixel TexturedVS( float4 inPos : POSITION, float3 inNormal: NORMAL, float2 inTexCoords: TEXCOORD0)
{
TVertexToPixel Output = (TVertexToPixel)0;
float4x4 preViewProjection = mul (xView, xProjection);
float4x4 preWorldViewProjection = mul (xWorld, preViewProjection);
Output.Position = mul(inPos, preWorldViewProjection);
Output.TextureCoords = inTexCoords;
float3 Normal = normalize(mul(normalize(inNormal), xWorld));
Output.LightingFactor = 1;
if (xEnableLighting)
Output.LightingFactor = saturate(dot(Normal, -xLightDirection));
return Output;
}
TPixelToFrame TexturedPS(TVertexToPixel PSIn)
{
TPixelToFrame Output = (TPixelToFrame)0;
Output.Color = tex2D(TextureSampler, PSIn.TextureCoords);
Output.Color.rgb *= saturate(PSIn.LightingFactor + xAmbient);
return Output;
}
technique Textured_2_0
{
pass Pass0
{
VertexShader = compile vs_2_0 TexturedVS();
PixelShader = compile ps_2_0 TexturedPS();
}
}
technique Textured
{
pass Pass0
{
VertexShader = compile vs_1_1 TexturedVS();
PixelShader = compile ps_2_0 TexturedPS();
}
}
//------- Technique: Multitextured --------
struct MTVertexToPixel
{
float4 Position : POSITION;
float4 Color : COLOR0;
float3 Normal : TEXCOORD0;
float2 TextureCoords : TEXCOORD1;
float4 LightDirection : TEXCOORD2;
float4 TextureWeights : TEXCOORD3;
float Depth : TEXCOORD4;
float4 clipDistances : TEXCOORD5;
};
struct MTPixelToFrame
{
float4 Color : COLOR0;
};
MTVertexToPixel MultiTexturedVS( float4 inPos : POSITION, float3 inNormal: NORMAL, float2 inTexCoords: TEXCOORD0, float4 inTexWeights: TEXCOORD1)
{
MTVertexToPixel Output = (MTVertexToPixel)0;
float4x4 preViewProjection = mul (xView, xProjection);
float4x4 preWorldViewProjection = mul (xWorld, preViewProjection);
Output.Position = mul(inPos, preWorldViewProjection);
Output.Normal = mul(normalize(inNormal), xWorld);
Output.TextureCoords = inTexCoords;
Output.LightDirection.xyz = -xLightDirection;
Output.LightDirection.w = 1;
Output.TextureWeights = inTexWeights;
Output.Depth = Output.Position.z/Output.Position.w;
Output.clipDistances = dot(inPos, ClipPlane0); //MSS - Water Refactor added
return Output;
}
MTPixelToFrame MultiTexturedPS(MTVertexToPixel PSIn)
{
MTPixelToFrame Output = (MTPixelToFrame)0;
float lightingFactor = 1;
if (xEnableLighting)
lightingFactor = saturate(saturate(dot(PSIn.Normal, PSIn.LightDirection)) + xAmbient);
float blendDistance = 0.99f;
float blendWidth = 0.005f;
float blendFactor = clamp((PSIn.Depth-blendDistance)/blendWidth, 0, 1);
float4 farColor;
farColor = tex2D(TextureSampler0, PSIn.TextureCoords)*PSIn.TextureWeights.x;
farColor += tex2D(TextureSampler1, PSIn.TextureCoords)*PSIn.TextureWeights.y;
farColor += tex2D(TextureSampler2, PSIn.TextureCoords)*PSIn.TextureWeights.z;
farColor += tex2D(TextureSampler3, PSIn.TextureCoords)*PSIn.TextureWeights.w;
float4 nearColor;
float2 nearTextureCoords = PSIn.TextureCoords*3;
nearColor = tex2D(TextureSampler0, nearTextureCoords)*PSIn.TextureWeights.x;
nearColor += tex2D(TextureSampler1, nearTextureCoords)*PSIn.TextureWeights.y;
nearColor += tex2D(TextureSampler2, nearTextureCoords)*PSIn.TextureWeights.z;
nearColor += tex2D(TextureSampler3, nearTextureCoords)*PSIn.TextureWeights.w;
Output.Color = lerp(nearColor, farColor, blendFactor);
Output.Color *= lightingFactor;
//Output.Color *= lightingFactor;
if (Clipping)
clip(PSIn.clipDistances); //MSS - Water Refactor added
return Output;
}
technique MultiTextured
{
pass Pass0
{
VertexShader = compile vs_1_1 MultiTexturedVS();
PixelShader = compile ps_2_0 MultiTexturedPS();
}
}
//------- Technique: Water --------
struct WVertexToPixel
{
float4 Position : POSITION;
float4 ReflectionMapSamplingPos : TEXCOORD1;
float2 BumpMapSamplingPos : TEXCOORD2;
float4 RefractionMapSamplingPos : TEXCOORD3;
float4 Position3D : TEXCOORD4;
};
struct WPixelToFrame
{
float4 Color : COLOR0;
};
WVertexToPixel WaterVS(float4 inPos : POSITION, float2 inTex: TEXCOORD)
{
WVertexToPixel Output = (WVertexToPixel)0;
float4x4 preViewProjection = mul (xView, xProjection);
float4x4 preWorldViewProjection = mul (xWorld, preViewProjection);
float4x4 preReflectionViewProjection = mul (xReflectionView, xProjection);
float4x4 preWorldReflectionViewProjection = mul (xWorld, preReflectionViewProjection);
Output.Position = mul(inPos, preWorldViewProjection);
Output.ReflectionMapSamplingPos = mul(inPos, preWorldReflectionViewProjection);
Output.RefractionMapSamplingPos = mul(inPos, preWorldViewProjection);
Output.Position3D = mul(inPos, xWorld);
float3 windDir = normalize(xWindDirection);
float3 perpDir = cross(xWindDirection, float3(0,1,0));
float ydot = dot(inTex, xWindDirection.xz);
float xdot = dot(inTex, perpDir.xz);
float2 moveVector = float2(xdot, ydot);
moveVector.y += xTime*xWindForce;
Output.BumpMapSamplingPos = moveVector/xWaveLength;
return Output;
}
WPixelToFrame WaterPS(WVertexToPixel PSIn)
{
WPixelToFrame Output = (WPixelToFrame)0;
float4 bumpColor = tex2D(WaterBumpMapSampler, PSIn.BumpMapSamplingPos);
float2 perturbation = xWaveHeight*(bumpColor.rg - 0.5f)*2.0f;
float2 ProjectedTexCoords;
ProjectedTexCoords.x = PSIn.ReflectionMapSamplingPos.x/PSIn.ReflectionMapSamplingPos.w/2.0f + 0.5f;
ProjectedTexCoords.y = -PSIn.ReflectionMapSamplingPos.y/PSIn.ReflectionMapSamplingPos.w/2.0f + 0.5f;
float2 perturbatedTexCoords = ProjectedTexCoords + perturbation;
float4 reflectiveColor = tex2D(ReflectionSampler, perturbatedTexCoords);
float2 ProjectedRefrTexCoords;
ProjectedRefrTexCoords.x = PSIn.RefractionMapSamplingPos.x/PSIn.RefractionMapSamplingPos.w/2.0f + 0.5f;
ProjectedRefrTexCoords.y = -PSIn.RefractionMapSamplingPos.y/PSIn.RefractionMapSamplingPos.w/2.0f + 0.5f;
float2 perturbatedRefrTexCoords = ProjectedRefrTexCoords + perturbation;
float4 refractiveColor = tex2D(RefractionSampler, perturbatedRefrTexCoords);
float3 eyeVector = normalize(xCamPos - PSIn.Position3D);
float3 normalVector = (bumpColor.rbg-0.5f)*2.0f;
float fresnelTerm = dot(eyeVector, normalVector);
float4 combinedColor = lerp(reflectiveColor, refractiveColor, fresnelTerm);
float4 dullColor = float4(0.3f, 0.3f, 0.5f, 1.0f);
Output.Color = lerp(combinedColor, dullColor, 0.2f);
float3 reflectionVector = -reflect(xLightDirection, normalVector);
float specular = dot(normalize(reflectionVector), normalize(eyeVector));
specular = pow(abs(specular), 256);
Output.Color.rgb += specular;
return Output;
}
technique Water
{
pass Pass0
{
VertexShader = compile vs_1_1 WaterVS();
PixelShader = compile ps_2_0 WaterPS();
}
}
//------- Technique: PerlinNoise --------
struct PNVertexToPixel
{
float4 Position : POSITION;
float2 TextureCoords : TEXCOORD0;
};
struct PNPixelToFrame
{
float4 Color : COLOR0;
};
PNVertexToPixel PerlinVS(float4 inPos : POSITION, float2 inTexCoords: TEXCOORD)
{
PNVertexToPixel Output = (PNVertexToPixel)0;
Output.Position = inPos;
Output.TextureCoords = inTexCoords;
return Output;
}
PNPixelToFrame PerlinPS(PNVertexToPixel PSIn)
{
PNPixelToFrame Output = (PNPixelToFrame)0;
float2 move = float2(0,1);
float4 perlin = tex2D(TextureSampler, (PSIn.TextureCoords)+xTime*move)/2;
perlin += tex2D(TextureSampler, (PSIn.TextureCoords)*2+xTime*move)/4;
perlin += tex2D(TextureSampler, (PSIn.TextureCoords)*4+xTime*move)/8;
perlin += tex2D(TextureSampler, (PSIn.TextureCoords)*8+xTime*move)/16;
perlin += tex2D(TextureSampler, (PSIn.TextureCoords)*16+xTime*move)/32;
perlin += tex2D(TextureSampler, (PSIn.TextureCoords)*32+xTime*move)/32;
Output.Color.rgb = 1.0f-pow(abs(perlin.r), xOvercast)*2.0f;
Output.Color.a =1;
return Output;
}
technique PerlinNoise
{
pass Pass0
{
VertexShader = compile vs_1_1 PerlinVS();
PixelShader = compile ps_2_0 PerlinPS();
}
}
//------- Technique: SkyDome --------
struct SDVertexToPixel
{
float4 Position : POSITION;
float2 TextureCoords : TEXCOORD0;
float4 ObjectPosition : TEXCOORD1;
};
struct SDPixelToFrame
{
float4 Color : COLOR0;
};
SDVertexToPixel SkyDomeVS( float4 inPos : POSITION, float2 inTexCoords: TEXCOORD0)
{
SDVertexToPixel Output = (SDVertexToPixel)0;
float4x4 preViewProjection = mul (xView, xProjection);
float4x4 preWorldViewProjection = mul (xWorld, preViewProjection);
Output.Position = mul(inPos, preWorldViewProjection);
Output.TextureCoords = inTexCoords;
Output. ObjectPosition = inPos;
return Output;
}
SDPixelToFrame SkyDomePS(SDVertexToPixel PSIn)
{
SDPixelToFrame Output = (SDPixelToFrame)0;
float4 topColor = float4(0.3f, 0.3f, 0.8f, 1);
float4 bottomColor = 1;
float4 baseColor = lerp(bottomColor, topColor, saturate((PSIn. ObjectPosition.y)/0.4f));
float4 cloudValue = tex2D(TextureSampler, PSIn.TextureCoords).r;
Output.Color = lerp(baseColor,1, cloudValue);
return Output;
}
technique SkyDome
{
pass Pass0
{
VertexShader = compile vs_1_1 SkyDomeVS();
PixelShader = compile ps_2_0 SkyDomePS();
}
} |
| |
|
| | | | | | Poster | : IronCladC | | Posts | : 4 | | Country | : Britain | | City | : London |
| | | | Posted by IronCladC on 05/07/2011 at 04:49:30
| | | Fantastic - Thanks Yagir1! | |
|
| | | | | | Poster | : Anonymous | | Posts | : | | Country | : | | City | : |
| | | | Posted by Anonymous on 18/01/2012 at 08:14:49
| | Even when using this adapted code I still get
"
Error 1 Errors compiling h:Visual Studio 2010ProjectsXNASeries4XNASeries4ContentbbEffect.fx:
error X3539: ps_1_x is no longer supported
h:Visual Studio 2010ProjectsXNASeries4XNASeries4ContentbbEffect.fx(62,24): ID3DXEffectCompiler::CompileEffect: There was an error compiling expression
ID3DXEffectCompiler: Compilation failed h:Visual Studio 2010ProjectsXNASeries4XNASeries4ContentbbEffect.fx 62 24 XNASeries4
" | |
|
| | | | | | Poster | : Anonymous | | Posts | : | | Country | : | | City | : |
| | | | Posted by Anonymous on 09/02/2012 at 21:25:43
| | To fix your error double click the error and replace the code with this
VertexShader = compile vs_2_0 CylBillboardVS();
PixelShader = compile ps_2_0 BillboardPS();
|
| |
|
| | | | | | Poster | : Kiaurutis | | Posts | : 2 | | Country | : Lithuania | | City | : VIlkaviskis |
| | | | Posted by Kiaurutis on 09/09/2012 at 08:32:50
| | I changed original code into Your code, changed shader versions to 2_0 in all effect files, but this line in Game1.cs:
effect.Parameters["ClipPlane0"].SetValue(new Vector4(refractionPlane.Normal, refractionPlane.D));
Gives me error:
NullReferenceException was unhandled. Object reference not set to an instance of an object.
Maybe I skipped any necessary changes in code? It is so difficult to start XNA 4.0 programming... cant find any working tutorials for advanced terrain :_( | |
|
|
 | | |  |
|
|
|
If you appreciate the amount of time I spend creating and updating
these pages, feel free to donate -- any amount is welcome !
|
- Website design & DirectX code : Riemer Grootjans -
©2006 Riemer Grootjans
|
|
