Wasser Wellen-Animation in Monogame

    • .NET (FX) 4.5–4.8
    • C#

    Es gibt 4 Antworten in diesem Thema. Der letzte Beitrag () ist von φConst.

      Wasser Wellen-Animation in Monogame

      [UPDATE FÜR SOURCE-CODE AUSTAUSCH]
      @Moderation : Danke sehr ( = !

      Guten Tag liebe Community,
      im Folgenden möchte ich Euch die Source für eine Wellen-Animation in Monogame bereitstellen...

      Es umfasst zwei Klassen, jeweils der WaterManager und eine individuelle Vertex Deklaration ( die ich WaterMolecule nenne ^^ )...

      Die WaterManager-Klasse

      C#-Quellcode

      1. public class WaterManager
      2. {
      4. public GraphicsDevice Device { get; private set; }
      5. public ContentManager Content { get; private set; }
      7. public DynamicVertexBuffer VertexBuffer { get; private set; }
      8. public DynamicIndexBuffer IndexBuffer { get; private set; }
      10. private List<WaterMolecule> mainVertices = new List<WaterMolecule>();
      12. private Dictionary<Vector3, int> hashTable = new Dictionary<Vector3, int>();
      14. private List<int> vertexIndices = new List<int>();
      16. private static Random RAND = new Random();
      18. private Texture2D waterTexture;
      19. private Effect waveEffect;
      20. private float animationTime;
      22. private WaterMolecule[] vertexPuffer;
      24. public WaterManager(GraphicsDevice device, ContentManager content)
      25. {
      26. Device = device;
      27. Content = content;
      29. waterTexture = Content.Load<Texture2D>(@"water");
      30. waveEffect = Content.Load<Effect>(@"wave");
      33. }
      35. public void AddWaterTile(Vector3 position)
      36. {
      37. // ADD VERTICES
      38. var wavefactor = (float)RAND.NextDouble() * 0.35f;
      39. wavefactor = RAND.NextDouble() >= 0.5 ? -wavefactor : wavefactor;
      41. if (vertexPuffer != null)
      42. mainVertices = new List<WaterMolecule>(vertexPuffer);
      43. else mainVertices = new List<WaterMolecule>();
      44. // CORNERS
      46. Vector3 local = position;
      47. Vector3 forward = new Vector3(position.X, position.Y, position.Z + 1);
      48. Vector3 left = new Vector3(position.X + 1, position.Y, position.Z);
      49. Vector3 leftForward = new Vector3(position.X + 1, position.Y, position.Z + 1);
      51. if (!mainVertices.Exists(p => p.Position.Equals(local)))
      52. {
      53. mainVertices.Add(new WaterMolecule(local, Vector3.Zero, new Vector2(position.X, position.Z), new Vector2(wavefactor)));
      54. hashTable.Add(local, mainVertices.Count - 1);
      55. }
      56. if (!mainVertices.Exists(p => p.Position.Equals(forward)))
      57. {
      58. mainVertices.Add(new WaterMolecule(forward, Vector3.Zero, new Vector2(forward.X, forward.Z), new Vector2(wavefactor)));
      59. hashTable.Add(forward, mainVertices.Count - 1);
      60. }
      61. if (!mainVertices.Exists(p => p.Position.Equals(left)))
      62. {
      63. mainVertices.Add(new WaterMolecule(left, Vector3.Zero, new Vector2(left.X, left.Z), new Vector2(wavefactor)));
      64. hashTable.Add(left, mainVertices.Count - 1);
      65. }
      66. if (!mainVertices.Exists(p => p.Position.Equals(leftForward)))
      67. {
      68. mainVertices.Add(new WaterMolecule(leftForward, Vector3.Zero, new Vector2(leftForward.X, leftForward.Z), new Vector2(wavefactor)));
      69. hashTable.Add(leftForward, mainVertices.Count - 1);
      70. }
      72. vertexIndices.Add(hashTable[local]);
      73. vertexIndices.Add(hashTable[left]);
      74. vertexIndices.Add(hashTable[leftForward]);
      76. vertexIndices.Add(hashTable[leftForward]);
      77. vertexIndices.Add(hashTable[forward]);
      78. vertexIndices.Add(hashTable[local]);
      80. ReInitialize();
      81. }
      83. private void ReInitialize()
      84. {
      85. VertexBuffer = new DynamicVertexBuffer(Device, typeof(WaterMolecule), mainVertices.Count, BufferUsage.None);
      86. IndexBuffer = new DynamicIndexBuffer(Device, IndexElementSize.ThirtyTwoBits, vertexIndices.Count, BufferUsage.None);
      88. VertexBuffer.SetData<WaterMolecule>(mainVertices.ToArray());
      89. IndexBuffer.SetData<int>(vertexIndices.ToArray());
      91. vertexPuffer = mainVertices.ToArray();
      92. mainVertices.Clear();
      94. }
      96. private void SetUpN()
      97. {
      99. Task.Run(() =>
      100. {
      101. for (int i = 0; i < vertexPuffer.Length; i++)
      102. {
      103. WaterMolecule molecule = vertexPuffer[i];
      104. float waveFactor = molecule.WaveFactor.X;
      106. Vector3 suVector = molecule.Position;
      108. Vector3 aVector = Vector3.Zero;
      109. Vector3 bVecot = Vector3.Zero;
      111. int index0 = 0;
      112. int index1 = 0;
      114. var a = hashTable.TryGetValue(new Vector3(suVector.X + 1, suVector.Y, suVector.Z), out index0);
      115. var b = hashTable.TryGetValue(new Vector3(suVector.X, suVector.Y, suVector.Z + 1), out index1);
      116. if (a)
      117. aVector = vertexPuffer[index0].Position;
      118. if (b)
      119. bVecot = vertexPuffer[index1].Position;
      121. suVector.Y += 0.35f * (float)(Math.Sin(animationTime * waveFactor));
      123. Vector3 dir0 = aVector - suVector;
      124. Vector3 dir1 = bVecot - suVector;
      126. Vector3 n = Vector3.Cross(dir0, dir1);
      128. molecule.Normal = n * n;
      129. vertexPuffer[i] = molecule;
      131. }
      132. });
      133. }
      135. public void Update(GameTime gTime)
      136. {
      137. animationTime += 25.0f * (float)gTime.ElapsedGameTime.TotalSeconds;
      138. SetUpN();
      140. waveEffect.Parameters["GlobalTime"].SetValue(animationTime);
      141. }
      143. public void Render(Matrix view, Matrix projection, Matrix world)
      144. {
      145. if (VertexBuffer == null)
      146. return;
      148. Task.Run(() =>
      149. {
      150. VertexBuffer.SetData<WaterMolecule>(vertexPuffer);
      151. });
      153. Device.SetVertexBuffer(VertexBuffer);
      154. Device.Indices = IndexBuffer;
      156. waveEffect.CurrentTechnique = waveEffect.Techniques["main"];
      158. waveEffect.Parameters["Texture0"].SetValue(waterTexture);
      160. waveEffect.Parameters["World"].SetValue(world);
      161. waveEffect.Parameters["View"].SetValue(view);
      162. waveEffect.Parameters["Projection"].SetValue(projection);
      163. waveEffect.Parameters["WorldInverseTranspose"].SetValue(Matrix.Transpose(Matrix.Invert(world)));
      165. waveEffect.CurrentTechnique.Passes[0].Apply();
      167. Device.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, vertexPuffer.Length * 2);
      168. }
      170. }


      WaterMolecule-Vertex-Deklaration:

      C#-Quellcode

      1. [StructLayout(LayoutKind.Sequential, Pack = 1)]
      2. public struct WaterMolecule : IVertexType
      3. {
      5. private static VertexDeclaration VertexPositionMolecule = new VertexDeclaration
      6. (
      7. new VertexElement(0, VertexElementFormat.Vector3, VertexElementUsage.Position, 0),
      8. new VertexElement(12, VertexElementFormat.Vector3, VertexElementUsage.Normal, 0),
      9. new VertexElement(24, VertexElementFormat.Vector2, VertexElementUsage.TextureCoordinate, 0),
      10. new VertexElement(32, VertexElementFormat.Vector2, VertexElementUsage.TextureCoordinate, 1)
      11. );
      13. public VertexDeclaration VertexDeclaration
      14. {
      15. get { return VertexPositionMolecule; }
      16. }
      18. public Vector3 Position;
      19. public Vector3 Normal;
      20. public Vector2 TextureCoordinate;
      21. public Vector2 WaveFactor;
      23. public WaterMolecule(Vector3 position, Vector3 normal, Vector2 textureCoordinate, Vector2 wavefac)
      24. : this()
      25. {
      26. Position = position;
      27. Normal = normal;
      28. TextureCoordinate = textureCoordinate;
      29. WaveFactor = wavefac;
      30. }
      32. }


      Die HLSL Klasse:

      C#-Quellcode

      1. #if OPENGL
      2. #define VS_SHADERMODEL vs_4_0
      3. #define PS_SHADERMODEL ps_4_0
      4. #else
      5. #define VS_SHADERMODEL vs_4_0_level_9_1
      6. #define PS_SHADERMODEL ps_4_0_level_9_1
      7. #endif
      9. float4x4 World;
      10. float4x4 View;
      11. float4x4 Projection;
      13. Texture Texture0;
      14. sampler Sampler0 = sampler_state {
      15. Texture = (Texture0);
      16. MinFilter = Linear;
      17. MagFilter = Linear;
      18. AddressU = Clamp;
      19. AddressV = Clamp;
      20. };
      22. float GlobalTime;
      24. float4 AmbientColor = float4(1, 1, 1, 1);
      25. float AmbientIntensity = 0.1;
      27. float4x4 WorldInverseTranspose;
      29. float3 DiffuseLightDirection = float3(1, 0, 0);
      30. float4 DiffuseColor = float4(1, 1, 1, 1);
      31. float DiffuseIntensity = 5;
      33. float Shininess = 450;
      34. float4 SpecularColor = float4(1, 1, 1, 1);
      35. float SpecularIntensity = .15f;
      36. float3 ViewVector = float3(1, 0, .1f);
      38. struct VertexShaderInput
      39. {
      40. float4 Position : POSITION0;
      41. float4 Normal : NORMAL0;
      42. float2 TextureCoordinates : TEXCOORD0;
      43. float2 WaveValue: TEXCOORD1;
      44. };
      46. struct VertexShaderOutput
      47. {
      48. float4 Position : POSITION0;
      49. float2 TextureCoordinates : TEXCOORD0;
      50. float3 Normal : TEXCOORD1;
      51. float4 Color : COLOR0;
      52. };
      54. VertexShaderOutput MainVS(VertexShaderInput input)
      55. {
      56. VertexShaderOutput output;
      58. float4 worldPosition = mul(input.Position, World);
      59. float4 viewPosition = mul(worldPosition, View);
      61. float4 pos = mul(viewPosition, Projection);
      62. output.Position = float4(pos.x, pos.y + 0.45f * sin(GlobalTime * input.WaveValue.x), pos.z, pos.w);
      64. float4 normal = normalize(mul(input.Normal, WorldInverseTranspose));
      65. float lightIntensity = dot(normal, float4(DiffuseLightDirection.x,DiffuseLightDirection.y,DiffuseLightDirection.z, .3f));
      66. output.Color = saturate(DiffuseColor * DiffuseIntensity * lightIntensity);
      68. output.Normal = float3(input.Normal.x, input.Normal.y, input.Normal.z);
      70. output.TextureCoordinates = input.TextureCoordinates;
      72. return output;
      73. }
      75. float4 MainPS(VertexShaderOutput input) : COLOR
      76. {
      77. float3 light = normalize(DiffuseLightDirection);
      78. float3 normal = normalize(input.Normal);
      79. float3 r = normalize(2 * dot(light, normal) * normal - light);
      80. float4 multiplication = mul(normalize(float4(ViewVector.x,ViewVector.y,ViewVector.z,1)), World);
      81. float3 v = normalize(multiplication.xyz);
      82. float dotProduct = dot(r, v.xyz);
      84. float4 specular = SpecularIntensity * SpecularColor * max(pow(abs(dotProduct), Shininess), 0) * length(input.Color);
      86. float4 textureColor = tex2D(Sampler0, input.TextureCoordinates);
      87. textureColor.a = .35f;
      89. return saturate(textureColor * (input.Color) + AmbientColor * AmbientIntensity + specular);
      91. }
      93. technique main
      94. {
      95. pass P0
      96. {
      97. VertexShader = compile VS_SHADERMODEL MainVS();
      98. PixelShader = compile PS_SHADERMODEL MainPS();
      99. }
      100. };




      Im Anhang ein Exempel ( =
      Dateien

      • WaterWaves.zip

        (452,14 kB, 212 mal heruntergeladen, zuletzt: )
      Und Gott alleine weiß alles am allerbesten und besser.

      Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „φConst“ ()

      Gibt es einen Grund, dass du das als extra task laufen lässt?
      Bedenke, Tasks starten braucht auch Leistung. Außerdem wartest du nirgends darauf, dass der Task abgeschlossen wird. Ist das so richtig?


      Opensource Audio-Bibliothek auf github: KLICK, im Showroom oder auf NuGet.

      Mit neuem Task auf einem relativ alten Laptop ~58-60 FPS ohne 28-30.
      Im Moment versuche ich sowieso die Methode im Shader zu implementieren.
      Sollte theoretisch über eine individuelle Vertex Deklaration möglich sein; also die Höhe der beiden anliegenden Vertices in die Grafikkarte zu übertragen und dann eben den Prozess (sinus) für die beiden Vertices zu simulieren.



      Und Gott alleine weiß alles am allerbesten und besser.

      *Würg* Der Versuch die Senkrechte auf der Grafikkarte zu berechnen...: Das Ergebnis ist ** ;
      (eigentlich gar nicht schlecht; eben aber nicht perfekt wie mit der CPU):



      Das Problem ist, dass das Licht scheinbar wabenförmig ist... was ja jedoch nicht sein darf lol.

      Hier die Ausschnitte aus dem Projekt:
      Shader:

      C#-Quellcode

      1. #if OPENGL
      2. #define VS_SHADERMODEL vs_4_0
      3. #define PS_SHADERMODEL ps_4_0
      4. #else
      5. #define VS_SHADERMODEL vs_4_0_level_9_1
      6. #define PS_SHADERMODEL ps_4_0_level_9_1
      7. #endif
      9. float4x4 World;
      10. float4x4 View;
      11. float4x4 Projection;
      12. float4x4 Light;
      14. Texture Texture0;
      15. sampler Sampler0 = sampler_state {
      16. Texture = (Texture0);
      17. MinFilter = Linear;
      18. MagFilter = Linear;
      19. AddressU = Clamp;
      20. AddressV = Clamp;
      21. };
      23. float GlobalTime;
      25. float4 AmbientColor = float4(1, 1, 1, 1);
      26. float AmbientIntensity = 0.1;
      28. float4x4 WorldInverseTranspose;
      30. float3 DiffuseLightDirection = float3(1, 0, .01f);
      31. float4 DiffuseColor = float4(1, 1, 1, 1);
      32. float DiffuseIntensity = 10;
      34. float Shininess = 450;
      35. float4 SpecularColor = float4(1, 1, 1, 1);
      36. float SpecularIntensity = .15f;
      37. float3 ViewVector = float3(1, 0, 0);
      39. struct VertexShaderInput
      40. {
      41. float4 Position : POSITION0;
      42. //float4 Normal : NORMAL0;
      43. float2 TextureCoordinates : TEXCOORD0;
      45. float2 WaveValue: TEXCOORD1;
      46. float2 WaveValue_Right: TEXCOORD2;
      47. float2 WaveValue_Forward: TEXCOORD3;
      48. };
      50. struct VertexShaderOutput
      51. {
      52. float4 Position : POSITION0;
      53. float2 TextureCoordinates : TEXCOORD0;
      54. float3 Normal : TEXCOORD1;
      55. float4 Color : COLOR0;
      56. };
      58. VertexShaderOutput MainVS(VertexShaderInput input)
      59. {
      60. VertexShaderOutput output;
      62. // LOCAL
      63. float4 worldPositionLocal = mul(input.Position, World);
      64. float4 viewPositionLocal = mul(worldPositionLocal, Light);
      66. float4 posLocal = mul(viewPositionLocal, Projection);
      67. float4 vecO = float4(posLocal.x, posLocal.y + 0.45f * cos(GlobalTime * input.WaveValue.x), posLocal.z, posLocal.w);
      69. //RIGHT
      70. float4 worldPositionU = mul(float4(input.Position.x + 1, input.Position.y, input.Position.z, input.Position.w), World);
      71. float4 viewPositionU = mul(worldPositionU, Light);
      73. float4 posU = mul(viewPositionU, Projection);
      74. float4 vecU = float4(posU.x, posU.y + 0.45f * cos(GlobalTime * input.WaveValue_Right.x), posU.z, posU.w);
      76. // FORWARD
      77. float4 worldPositionV = mul(float4(input.Position.x, input.Position.y, input.Position.z + 1, input.Position.w), World);
      78. float4 viewPositionV = mul(worldPositionV, Light);
      80. float4 posV = mul(viewPositionV, Projection);
      81. float4 vecV = float4(posV.x, posV.y + 0.45f * cos(GlobalTime * input.WaveValue_Forward.x), posV.z, posV.w);
      83. // DIRECTIONS
      84. float4 directU = vecU - vecO;
      85. float4 directV = vecV - vecO;
      87. // CROSS
      89. float3 crossVec = cross(directU, directV);
      90. float3 vecN = crossVec * crossVec * crossVec* crossVec;
      92. // ---
      94. worldPositionLocal = mul(input.Position, World);
      95. viewPositionLocal = mul(worldPositionLocal, View);
      97. posLocal = mul(viewPositionLocal, Projection);
      98. vecO = float4(posLocal.x, posLocal.y + 0.45f * cos(GlobalTime * input.WaveValue.x), posLocal.z, posLocal.w);
      100. output.Position = vecO;
      103. float4 normal = normalize(mul(float4(vecN.x, vecN.y, vecN.z, 1), WorldInverseTranspose));
      104. float lightIntensity = dot(normal, float4(DiffuseLightDirection.x,DiffuseLightDirection.y,DiffuseLightDirection.z, .3f));
      105. output.Color = saturate(DiffuseColor * DiffuseIntensity * lightIntensity);
      106. output.Normal = float3(vecN.x, vecN.y, vecN.z);
      108. output.TextureCoordinates = input.TextureCoordinates;
      110. return output;
      111. }
      113. float4 MainPS(VertexShaderOutput input) : COLOR
      114. {
      115. float3 light = normalize(DiffuseLightDirection);
      116. float3 normal = normalize(input.Normal);
      117. float3 r = normalize(2 * dot(light, normal) * normal - light);
      118. float4 multiplication = mul(normalize(float4(ViewVector.x,ViewVector.y,ViewVector.z,1)), World);
      119. float3 v = normalize(multiplication.xyz);
      120. float dotProduct = dot(r, v.xyz);
      122. float4 specular = SpecularIntensity * SpecularColor * max(pow(abs(dotProduct), Shininess), 0) * length(input.Color);
      124. float4 textureColor = tex2D(Sampler0, input.TextureCoordinates);
      125. textureColor.a = .35f;
      127. return saturate(textureColor * (input.Color) + AmbientColor * AmbientIntensity + specular);
      129. }
      131. technique main
      132. {
      133. pass P0
      134. {
      135. VertexShader = compile VS_SHADERMODEL MainVS();
      136. PixelShader = compile PS_SHADERMODEL MainPS();
      137. }
      138. };​


      WaterMolecule ( Vertex-Deklaration):

      C#-Quellcode

      1. ​using Microsoft.Xna.Framework;
      2. using Microsoft.Xna.Framework.Graphics;
      3. using Microsoft.Xna.Framework.Input;
      4. using System;
      5. using System.Collections.Generic;
      6. using System.Runtime.InteropServices;
      7. namespace WaterWaves
      8. {
      9. [StructLayout(LayoutKind.Sequential, Pack = 1)]
      10. public struct WaterMolecule : IVertexType
      11. {
      13. private static VertexDeclaration VertexPositionMolecule = new VertexDeclaration
      14. (
      15. new VertexElement(0, VertexElementFormat.Vector3, VertexElementUsage.Position, 0),
      16. new VertexElement(12, VertexElementFormat.Vector2, VertexElementUsage.TextureCoordinate, 0),
      17. new VertexElement(20, VertexElementFormat.Vector2, VertexElementUsage.TextureCoordinate, 1),
      18. new VertexElement(28, VertexElementFormat.Vector2, VertexElementUsage.TextureCoordinate, 2),
      19. new VertexElement(36, VertexElementFormat.Vector2, VertexElementUsage.TextureCoordinate, 3)
      20. );
      22. public VertexDeclaration VertexDeclaration
      23. {
      24. get { return VertexPositionMolecule; }
      25. }
      27. public Vector3 Position;
      28. //public Vector3 Normal;
      29. public Vector2 TextureCoordinate;
      31. public Vector2 WaveFactor;
      32. public Vector2 WaveFactor_Right;
      33. public Vector2 WaveFacot_Forward;
      35. public WaterMolecule(Vector3 position, Vector2 textureCoordinate, Vector2 wavefac, Vector2 wavefac_right, Vector2 wavefac_forward)
      36. : this()
      37. {
      38. Position = position;
      39. //Normal = normal;
      40. TextureCoordinate = textureCoordinate;
      42. WaveFactor = wavefac;
      43. WaveFactor_Right = wavefac_right;
      44. WaveFacot_Forward = wavefac_forward;
      45. }
      47. }
      48. }


      WaterManager
      (Ich verwende SimplexNoiseGenerator damit ich auf die Höhen der anliegenden Vertices zugreifen kann):

      C#-Quellcode

      1. ​ public void AddWaterTile(Vector3 position)
      2. {
      3. // ADD VERTICES
      4. var wavefactor = (float)simplex.GetNoise2D((int)position.X, (int)position.Z);
      5. wavefactor *= 0.25f;
      7. var wavefactor_right = (float)simplex.GetNoise2D((int)position.X + 1, (int)position.Z);
      8. wavefactor_right *= 0.25f;
      10. var wavefactor_forward = (float)simplex.GetNoise2D((int)position.X, (int)position.Z + 1);
      11. wavefactor_forward *= 0.25f;
      13. Vector3 local = position;
      14. Vector3 forward = new Vector3(position.X, position.Y, position.Z + 1);
      15. Vector3 left = new Vector3(position.X + 1, position.Y, position.Z);
      16. Vector3 leftForward = new Vector3(position.X + 1, position.Y, position.Z + 1);
      18. if (!hashTable.ContainsKey(local))
      19. {
      20. mainVertices.Add(new WaterMolecule(local, new Vector2(position.X, position.Z), new Vector2(wavefactor), new Vector2(wavefactor_right), new Vector2(wavefactor_forward)));
      21. hashTable.Add(local, mainVertices.Count - 1);
      22. }
      23. if (!hashTable.ContainsKey(forward))
      24. {
      25. mainVertices.Add(new WaterMolecule(forward, new Vector2(forward.X, forward.Z), new Vector2(wavefactor), new Vector2(wavefactor_right), new Vector2(wavefactor_forward)));
      26. hashTable.Add(forward, mainVertices.Count - 1);
      27. }
      28. if (!hashTable.ContainsKey(left))
      29. {
      30. mainVertices.Add(new WaterMolecule(left, new Vector2(left.X, left.Z), new Vector2(wavefactor), new Vector2(wavefactor_right), new Vector2(wavefactor_forward)));
      31. hashTable.Add(left, mainVertices.Count - 1);
      32. }
      33. if (!hashTable.ContainsKey(leftForward))
      34. {
      35. mainVertices.Add(new WaterMolecule(leftForward, new Vector2(leftForward.X, leftForward.Z), new Vector2(wavefactor), new Vector2(wavefactor_right), new Vector2(wavefactor_forward)));
      36. hashTable.Add(leftForward, mainVertices.Count - 1);
      37. }
      39. vertexIndices.Add(hashTable[position]);
      41. vertexIndices.Add(hashTable[left]);
      42. vertexIndices.Add(hashTable[leftForward]);
      43. vertexIndices.Add(hashTable[leftForward]);
      44. vertexIndices.Add(hashTable[forward]);
      46. vertexIndices.Add(hashTable[position]);
      47. }
      Woran mag das liegen?
      Und Gott alleine weiß alles am allerbesten und besser.

      UPDATE

      Die Orthogonalen werden nun im Shader berechnet!
      Ein 450 * 450 großer Ozean kann perpetuell bei 55-60 Fps visualisiert werden.

      Der Shader:

      C-Quellcode

      1. #if OPENGL
      2. #define VS_SHADERMODEL vs_4_0
      3. #define PS_SHADERMODEL ps_4_0
      4. #else
      5. #define VS_SHADERMODEL vs_4_0_level_9_1
      6. #define PS_SHADERMODEL ps_4_0_level_9_1
      7. #endif
      9. float4x4 World;
      10. float4x4 View;
      11. float4x4 Projection;
      12. float4x4 Light;
      14. Texture Texture0;
      15. sampler Sampler0 = sampler_state {
      16. Texture = (Texture0);
      17. MinFilter = Linear;
      18. MagFilter = Linear;
      19. AddressU = Clamp;
      20. AddressV = Clamp;
      21. };
      23. float GlobalTime;
      25. float4 AmbientColor = float4(1, 1, 1, 1);
      26. float AmbientIntensity = 0.1;
      28. float4x4 WorldInverseTranspose;
      30. float3 DiffuseLightDirection = float3(1, 0, 0);
      31. float4 DiffuseColor = float4(1, 1, 1, 1);
      32. float DiffuseIntensity = 10;
      34. float Shininess = 450;
      35. float4 SpecularColor = float4(1, 1, 1, 1);
      36. float SpecularIntensity = .15f;
      37. float3 ViewVector = float3(1, 0, 0.1f);
      39. struct VertexShaderInput
      40. {
      41. float4 Position : POSITION0;
      42. float4 Position_Left : POSITION1;
      43. float4 Position_Top : POSITION2;
      44. float2 TextureCoordinates : TEXCOORD0;
      45. float2 WaveValue: TEXCOORD1;
      46. };
      48. struct VertexShaderOutput
      49. {
      50. float4 Position : POSITION0;
      51. float2 TextureCoordinates : TEXCOORD0;
      52. float3 Normal : TEXCOORD1;
      53. float4 Color : COLOR0;
      54. };
      56. VertexShaderOutput MainVS(VertexShaderInput input)
      57. {
      58. VertexShaderOutput output;
      60. // LOCAL
      61. float4 worldPositionLocal = mul(input.Position, World);
      62. float4 viewPositionLocal = mul(worldPositionLocal, Light);
      64. float4 posLocal = mul(viewPositionLocal, Projection);
      65. float4 vecO = float4(posLocal.x, posLocal.y + 0.55f * cos(GlobalTime * input.WaveValue.x), posLocal.z, posLocal.w);
      67. //RIGHT
      68. float4 worldPositionU = mul(input.Position_Left, World);
      69. float4 viewPositionU = mul(worldPositionU, Light);
      71. float4 posU = mul(viewPositionU, Projection);
      72. float4 vecU = posU;
      74. // FORWARD
      75. float4 worldPositionV = mul(input.Position_Top, World);
      76. float4 viewPositionV = mul(worldPositionV, Light);
      78. float4 posV = mul(viewPositionV, Projection);
      79. float4 vecV = posV;
      81. // DIRECTIONS
      82. float4 directU = vecU - vecO;
      83. float4 directV = vecV - vecO;
      85. // CROSS
      87. float3 crossVec = cross(float3(directU.x, directU.y, directU.z), float3(directV.x, directV.y, directV.z));
      88. float3 vecN = crossVec * crossVec;
      90. worldPositionLocal = mul(input.Position, World);
      91. viewPositionLocal = mul(worldPositionLocal, View);
      93. posLocal = mul(viewPositionLocal, Projection);
      94. vecO = float4(posLocal.x, posLocal.y + 0.45f * sin(GlobalTime * input.WaveValue.x), posLocal.z, posLocal.w);
      95. output.Position = vecO;
      97. float4 normal = normalize(mul(float4(vecN.x, vecN.y, vecN.z, 1), WorldInverseTranspose));
      98. float lightIntensity = dot(normal, float4(DiffuseLightDirection.x, DiffuseLightDirection.y, DiffuseLightDirection.z, .3f));
      99. output.Color = saturate(DiffuseColor * DiffuseIntensity * lightIntensity);
      100. output.Normal = float3(vecN.x, vecN.y, vecN.z);
      102. output.TextureCoordinates = input.TextureCoordinates;
      104. return output;
      105. }
      107. float4 MainPS(VertexShaderOutput input) : COLOR
      108. {
      109. float3 light = normalize(DiffuseLightDirection);
      110. float3 normal = normalize(input.Normal);
      111. float3 r = normalize(2 * dot(light, normal) * normal - light);
      112. float4 multiplication = mul(normalize(float4(ViewVector.x, ViewVector.y, ViewVector.z, 1)), World);
      113. float3 v = normalize(multiplication.xyz);
      114. float dotProduct = dot(r, v.xyz);
      116. float4 specular = SpecularIntensity * SpecularColor * max(pow(abs(dotProduct), Shininess), 0) * length(input.Color);
      118. float4 textureColor = tex2D(Sampler0, input.TextureCoordinates);
      119. textureColor.a = .35f;
      121. return saturate(textureColor * (input.Color) + AmbientColor * AmbientIntensity + specular);
      123. }
      125. technique main
      126. {
      127. pass P0
      128. {
      129. VertexShader = compile VS_SHADERMODEL MainVS();
      130. PixelShader = compile PS_SHADERMODEL MainPS();
      131. }
      132. };


      Die neue Vertex Deklaration:

      C#-Quellcode

      1. using Microsoft.Xna.Framework;
      2. using Microsoft.Xna.Framework.Graphics;
      3. using Microsoft.Xna.Framework.Input;
      4. using System;
      5. using System.Collections.Generic;
      6. using System.Runtime.InteropServices;
      7. namespace WaterWaves
      8. {
      9. [StructLayout(LayoutKind.Sequential, Pack = 1)]
      10. public struct WaterMolecule : IVertexType
      11. {
      12. private static VertexDeclaration VertexPositionMolecule = new VertexDeclaration
      13. (
      14. new VertexElement(0, VertexElementFormat.Vector3, VertexElementUsage.Position, 0),
      15. new VertexElement(12, VertexElementFormat.Vector3, VertexElementUsage.Position, 1),
      16. new VertexElement(24, VertexElementFormat.Vector3, VertexElementUsage.Position, 2),
      17. new VertexElement(36, VertexElementFormat.Vector2, VertexElementUsage.TextureCoordinate, 0),
      18. new VertexElement(44, VertexElementFormat.Vector2, VertexElementUsage.TextureCoordinate, 1)
      19. );
      20. public VertexDeclaration VertexDeclaration
      21. {
      22. get { return VertexPositionMolecule; }
      23. }
      25. public Vector3 Position;
      26. public Vector3 Position_Left;
      27. public Vector3 Position_Top;
      28. public Vector2 TextureCoordinate;
      29. public Vector2 WaveFactor;
      31. public WaterMolecule(Vector3 position, Vector3 pos_left, Vector3 pos_top, Vector2 textureCoordinate, Vector2 wavefac)
      32. : this()
      33. {
      34. Position = position;
      35. Position_Left = pos_left;
      36. Position_Top = pos_top;
      37. TextureCoordinate = textureCoordinate;
      38. WaveFactor = wavefac;
      39. }
      40. }
      41. }



      WaterManager:

      C#-Quellcode

      1. using Microsoft.Xna.Framework;
      2. using Microsoft.Xna.Framework.Content;
      3. using Microsoft.Xna.Framework.Graphics;
      4. using Microsoft.Xna.Framework.Input;
      5. using System;
      6. using System.Collections.Generic;
      7. using System.Runtime.InteropServices;
      8. using System.Threading.Tasks;
      10. namespace WaterWaves
      11. {
      12. public class WaterManager
      13. {
      14. public GraphicsDevice Device { get; private set; }
      15. public ContentManager Content { get; private set; }
      16. public DynamicVertexBuffer VertexBuffer { get; private set; }
      17. public DynamicIndexBuffer IndexBuffer { get; private set; }
      18. private List<WaterMolecule> mainVertices = new List<WaterMolecule>();
      19. private Dictionary<Vector3, int> hashTable = new Dictionary<Vector3, int>();
      20. private List<int> vertexIndices = new List<int>();
      21. private static Random RAND = new Random();
      22. private Texture2D waterTexture;
      23. private Effect waveEffect;
      24. private float animationTime;
      25. private WaterMolecule[] vertexPuffer;
      27. private SimplexNoiseGenerator simplex;
      29. public WaterManager(GraphicsDevice device, ContentManager content)
      30. {
      31. Device = device;
      32. Content = content;
      33. waterTexture = Content.Load<Texture2D>(@"water");
      34. waveEffect = Content.Load<Effect>(@"waves");
      36. simplex = new SimplexNoiseGenerator(299292, 1.0f / 256.0f, 1.0f / 256.0f, 1.0f / 256.0f);
      37. simplex.Factor = 1;
      38. simplex.Sealevel = 1;
      39. simplex.Octaves = 5;
      41. }
      42. public void AddWaterTile(Vector3 position)
      43. {
      44. // ADD VERTICES
      45. var wavefactor = (float)RAND.NextDouble() * 0.35f;
      46. wavefactor = RAND.NextDouble() >= 0.5 ? -wavefactor : wavefactor;
      48. Vector3 local = position;
      49. Vector3 forward = new Vector3(position.X, position.Y, position.Z + 1);
      50. Vector3 left = new Vector3(position.X + 1, position.Y, position.Z);
      51. Vector3 leftForward = new Vector3(position.X + 1, position.Y, position.Z + 1);
      52. if (!hashTable.ContainsKey(local))
      53. {
      54. mainVertices.Add(new WaterMolecule(local, local + Vector3.Right , local + Vector3.Forward, new Vector2(position.X, position.Z), new Vector2(wavefactor)));
      55. hashTable.Add(local, mainVertices.Count - 1);
      56. }
      57. if (!hashTable.ContainsKey(forward))
      58. {
      59. mainVertices.Add(new WaterMolecule(forward, forward + Vector3.Right, forward + Vector3.Forward, new Vector2(position.X, position.Z), new Vector2(wavefactor)));
      60. hashTable.Add(forward, mainVertices.Count - 1);
      61. }
      62. if (!hashTable.ContainsKey(left))
      63. {
      64. mainVertices.Add(new WaterMolecule(left, left + Vector3.Right, left + Vector3.Forward, new Vector2(position.X, position.Z), new Vector2(wavefactor)));
      65. hashTable.Add(left, mainVertices.Count - 1);
      66. }
      67. if (!hashTable.ContainsKey(leftForward))
      68. {
      69. mainVertices.Add(new WaterMolecule(leftForward, leftForward + Vector3.Right, leftForward + Vector3.Forward, new Vector2(position.X, position.Z), new Vector2(wavefactor)));
      70. hashTable.Add(leftForward, mainVertices.Count - 1);
      71. }
      72. vertexIndices.Add(hashTable[position]);
      73. vertexIndices.Add(hashTable[left]);
      74. vertexIndices.Add(hashTable[leftForward]);
      75. vertexIndices.Add(hashTable[leftForward]);
      76. vertexIndices.Add(hashTable[forward]);
      77. vertexIndices.Add(hashTable[position]);
      78. }
      79. public void Initialize()
      80. {
      81. VertexBuffer = new DynamicVertexBuffer(Device, typeof(WaterMolecule), mainVertices.Count, BufferUsage.None);
      82. IndexBuffer = new DynamicIndexBuffer(Device, IndexElementSize.ThirtyTwoBits, vertexIndices.Count, BufferUsage.None);
      83. VertexBuffer.SetData<WaterMolecule>(mainVertices.ToArray());
      84. IndexBuffer.SetData<int>(vertexIndices.ToArray());
      85. vertexPuffer = mainVertices.ToArray();
      86. mainVertices.Clear();
      88. }
      90. public void Update(GameTime gTime)
      91. {
      92. animationTime += 25.0f * (float)gTime.ElapsedGameTime.TotalSeconds;
      93. waveEffect.Parameters["GlobalTime"].SetValue(animationTime);
      94. }
      96. public void Render(Matrix view, Matrix projection, Matrix world)
      97. {
      98. if (VertexBuffer == null)
      99. return;
      100. Task.Run(() =>
      101. {
      102. VertexBuffer.SetData<WaterMolecule>(vertexPuffer);
      103. });
      104. Device.SetVertexBuffer(VertexBuffer);
      105. Device.Indices = IndexBuffer;
      106. waveEffect.CurrentTechnique = waveEffect.Techniques["main"];
      107. waveEffect.Parameters["Texture0"].SetValue(waterTexture);
      108. waveEffect.Parameters["Light"].SetValue(Camera.Light);
      109. waveEffect.Parameters["World"].SetValue(world);
      110. waveEffect.Parameters["View"].SetValue(view);
      111. waveEffect.Parameters["Projection"].SetValue(projection);
      112. waveEffect.Parameters["WorldInverseTranspose"].SetValue(Matrix.Transpose(Matrix.Invert(world)));
      113. waveEffect.CurrentTechnique.Passes[0].Apply();
      114. Device.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, vertexPuffer.Length * 2);
      115. }
      116. }
      117. }
      Und Gott alleine weiß alles am allerbesten und besser.

      Dieser Beitrag wurde bereits 4 mal editiert, zuletzt von „φConst“ ()

    Facebook
    Telefonspende