Adding Water C# example

FeatureExamples/Resources/Scripts/23_Water.cs

@@ -0,0 +1,188 @@
+//
+// Copyright (c) 2008-2015 the Urho3D project.
+// Copyright (c) 2015 Xamarin Inc
+// Copyright (c) 2016 THUNDERBEAST GAMES LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+using AtomicEngine;
+
+namespace FeatureExamples
+{
+	public class WaterSample : Sample
+	{
+		Scene scene;
+		Node waterNode;
+		Node reflectionCameraNode;
+		Plane waterPlane;
+		Plane waterClipPlane;
+
+        Graphics graphics;
+
+		public WaterSample() : base() {}
+
+        public override void Start()
+        {
+            graphics = GetSubsystem<Graphics>();
+
+            base.Start();
+			CreateScene();
+			SimpleCreateInstructionsWithWasd();
+			SetupViewport();
+        }
+
+        protected override void Update(float timeStep)
+        {
+			base.Update(timeStep);
+			SimpleMoveCamera3D(timeStep, 100f);
+			var camera = reflectionCameraNode.GetComponent<Camera>();
+			camera.AspectRatio = (float)graphics.Width / graphics.Height;
+		}
+
+		void SetupViewport()
+		{
+			var renderer = GetSubsystem<Renderer>();
+			var cache = GetSubsystem<ResourceCache>();
+
+			renderer.SetViewport(0, new Viewport(scene, CameraNode.GetComponent<Camera>()));
+
+			// Create a mathematical plane to represent the water in calculations
+
+			waterPlane = new Plane(waterNode.WorldRotation * new Vector3(0.0f, 1.0f, 0.0f), waterNode.WorldPosition);
+			// Create a downward biased plane for reflection view clipping. Biasing is necessary to avoid too aggressive clipping
+			waterClipPlane = new Plane(waterNode.WorldRotation * new Vector3(0.0f, 1.0f, 0.0f), waterNode.WorldPosition - new Vector3(0.0f, 0.1f, 0.0f));
+
+			// Create camera for water reflection
+			// It will have the same farclip and position as the main viewport camera, but uses a reflection plane to modify
+			// its position when rendering
+			reflectionCameraNode = CameraNode.CreateChild();
+			var reflectionCamera = reflectionCameraNode.CreateComponent<Camera>();
+			reflectionCamera.FarClip = 750.0f;
+			reflectionCamera.ViewMask= 0x7fffffff; // Hide objects with only bit 31 in the viewmask (the water plane)
+			reflectionCamera.AutoAspectRatio = false;
+			reflectionCamera.UseReflection = true;
+			reflectionCamera.ReflectionPlane = waterPlane;
+			reflectionCamera.UseClipping = true; // Enable clipping of geometry behind water plane
+			reflectionCamera.ClipPlane = waterClipPlane;
+			// The water reflection texture is rectangular. Set reflection camera aspect ratio to match
+			reflectionCamera.AspectRatio = (float)graphics.Width / graphics.Height;
+			// View override flags could be used to optimize reflection rendering. For example disable shadows
+			//reflectionCamera.ViewOverrideFlags = ViewOverrideFlags.DisableShadows;
+
+			// Create a texture and setup viewport for water reflection. Assign the reflection texture to the diffuse
+			// texture unit of the water material
+			int texSize = 1024;
+			Texture2D renderTexture = new Texture2D();
+			renderTexture.SetSize(texSize, texSize, Graphics.GetRGBFormat(), TextureUsage.TEXTURE_RENDERTARGET);
+			renderTexture.FilterMode = TextureFilterMode.FILTER_BILINEAR;
+			RenderSurface surface = renderTexture.RenderSurface;
+			var rttViewport = new Viewport(scene, reflectionCamera);
+			surface.SetViewport(0, rttViewport);
+			var waterMat = cache.Get<Material>("Materials/Water.xml");
+			waterMat.SetTexture(TextureUnit.TU_DIFFUSE, renderTexture);
+		}
+
+		void CreateScene()
+		{
+            var cache = GetSubsystem<ResourceCache>();
+            scene = new Scene();
+
+			// Create octree, use default volume (-1000, -1000, -1000) to (1000, 1000, 1000)
+			scene.CreateComponent<Octree>();
+
+			// Create a Zone component for ambient lighting & fog control
+			var zoneNode = scene.CreateChild("Zone");
+			var zone = zoneNode.CreateComponent<Zone>();
+			zone.SetBoundingBox(new BoundingBox(-1000.0f, 1000.0f));
+			zone.AmbientColor = new Color(0.15f, 0.15f, 0.15f);
+			zone.FogColor = new Color(1.0f, 1.0f, 1.0f);
+			zone.FogStart = 500.0f;
+			zone.FogEnd = 750.0f;
+
+			// Create a directional light to the world. Enable cascaded shadows on it
+			var lightNode = scene.CreateChild("DirectionalLight");
+			lightNode.SetDirection(new Vector3(0.6f, -1.0f, 0.8f));
+			var light = lightNode.CreateComponent<Light>();
+			light.LightType = LightType.LIGHT_DIRECTIONAL;
+			light.CastShadows = true;
+			light.ShadowBias = new BiasParameters(0.00025f, 0.5f);
+			light.ShadowCascade = new CascadeParameters(10.0f, 50.0f, 200.0f, 0.0f, 0.8f);
+			light.SpecularIntensity = 0.5f;
+			// Apply slightly overbright lighting to match the skybox
+			light.Color = new Color(1.2f, 1.2f, 1.2f);
+
+			// Create skybox. The Skybox component is used like StaticModel, but it will be always located at the camera, giving the
+			// illusion of the box planes being far away. Use just the ordinary Box model and a suitable material, whose shader will
+			// generate the necessary 3D texture coordinates for cube mapping
+			var skyNode = scene.CreateChild("Sky");
+			skyNode.SetScale(500.0f); // The scale actually does not matter
+			var skybox = skyNode.CreateComponent<Skybox>();
+			skybox.Model = cache.Get<Model>("Models/Box.mdl");
+			skybox.SetMaterial(cache.Get<Material>("Materials/Skybox.xml"));
+
+			// Create heightmap terrain
+			var terrainNode = scene.CreateChild("Terrain");
+			terrainNode.Position = new Vector3(0.0f, 0.0f, 0.0f);
+			var terrain = terrainNode.CreateComponent<Terrain>();
+			terrain.PatchSize = 64;
+			terrain.Spacing = new Vector3(2.0f, 0.5f, 2.0f); // Spacing between vertices and vertical resolution of the height map
+			terrain.Smoothing =true;
+			terrain.SetHeightMap(cache.Get<Image>("Textures/HeightMap.png"));
+			terrain.Material = cache.Get<Material>("Materials/Terrain.xml");
+			// The terrain consists of large triangles, which fits well for occlusion rendering, as a hill can occlude all
+			// terrain patches and other objects behind it
+			terrain.Occluder = true;
+
+			// Create 1000 boxes in the terrain. Always face outward along the terrain normal
+			uint numObjects = 1000;
+			for (uint i = 0; i < numObjects; ++i)
+			{
+				var objectNode = scene.CreateChild("Box");
+				Vector3 position = new Vector3(NextRandom(2000.0f) - 1000.0f, 0.0f, NextRandom(2000.0f) - 1000.0f);
+				position.Y = terrain.GetHeight(position) + 2.25f;
+				objectNode.Position = position;
+				// Create a rotation quaternion from up vector to terrain normal
+				objectNode.Rotation = Quaternion.FromRotationTo(new Vector3(0.0f, 1.0f, 0.0f), terrain.GetNormal(position));
+				objectNode.SetScale(5.0f);
+				var obj = objectNode.CreateComponent<StaticModel>();
+				obj.Model = cache.Get<Model>("Models/Box.mdl");
+				obj.SetMaterial(cache.Get<Material>("Materials/Stone.xml"));
+				obj.CastShadows = true;
+			}
+
+			// Create a water plane object that is as large as the terrain
+			waterNode = scene.CreateChild("Water");
+			waterNode.Scale = new Vector3(2048.0f, 1.0f, 2048.0f);
+			waterNode.Position = new Vector3(0.0f, 5.0f, 0.0f);
+			var water = waterNode.CreateComponent<StaticModel>();
+			water.Model = cache.Get<Model>("Models/Plane.mdl");
+			water.SetMaterial(cache.Get<Material>("Materials/Water.xml"));
+			// Set a different viewmask on the water plane to be able to hide it from the reflection camera
+			water.ViewMask = 0x80000000;
+
+
+			// Create the camera. Limit far clip distance to match the fog
+			CameraNode = new Node();
+			var camera = CameraNode.CreateComponent<Camera>();
+			camera.FarClip = 750.0f;
+			// Set an initial position for the camera scene node above the plane
+			CameraNode.Position = new Vector3(0.0f, 7.0f, -20.0f);
+		}
+	}
+}

FeatureExamples/Resources/Scripts/23_Water.cs.asset

@@ -0,0 +1,5 @@
+{
+	"version": 1,
+	"guid": "4c1a76f08b306b93b5c6ecbe7ad74166",
+	"CSharpImporter": null
+}