Unigine.ObjectWaterGlobal Class

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
using Unigine;

namespace UnigineApp
{
	class AppWorldLogic : WorldLogic
	{
		ObjectWaterGlobal water = null;
		
		/* ... */
		
		public override bool Init()
		{
			// Write here code to be called on world initialization: initialize resources for your world scene during the world start.
			
			// Changing preset to custom (4) and adjusting tesselation parameters
			Render.WaterGeometryPreset = 4;
			Render.WaterGeometryPolygonSize = 0.01f;
			Render.WaterGeometryProgression = 1.0f;
			Render.WaterGeometrySubpixelReduction = 6.0f;
			
			water = (ObjectWaterGlobal)World.GetNodeByType((int)Node.TYPE.OBJECT_WATER_GLOBAL);
			if (water == null)
			{
				water = new ObjectWaterGlobal();
			}	

			// You can set each wave only in Manual mode
			water.WavesMode = ObjectWaterGlobal.WAVES_MODE.MANUAL;

			// add each wave. 
			// addWave(wave length, amplitude, steepness, direction angle[0.0; 360.0], phase offset[0.0; 2*PI])

			water.AddWave(8.0f, 0.05f, 2.0f, 270.0f, 0.0f);
			water.AddWave(8.0f, 0.015f, 1.0f, 150.0f, 1.0f);
			water.AddWave(8.0f, 0.02f, 6.0f, 75.0f, 0.0f);
			water.AddWave(16.0f, 0.05f, 2.0f, 270.0f, 3.0f);
			water.AddWave(16.0f, 0.05f, 7.0f, 45.0f, 0.5f);
			water.AddWave(32.0f, 0.1f, 2.0f, 120.0f, 2.0f);
			water.AddWave(64.0f, 0.2f, 1.0f, -90.0f, 0.1f);
			
			// Changing amplitude and length for the second wave 
			water.SetWaveAmplitude(1, 0.03f);
			water.SetWaveLength(1, 10.0f);

			return true;
		}
		
		/* ... */
		
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using Unigine;

[Component(PropertyGuid = "AUTOGENERATED_GUID")] // <-- this line is generated automatically for a new component
public class WaterFetchIntersection : Component
{
	// Object Water Global node to perform requests for
	public Node water_node;
	
	// Fetch request mode flag (false - means Intersection request)
	private bool fetch = true; 
	
	// size and number of points
	private int num_intersection = 100;
	private float intersect_point_size = 0.2f;
	
	
	//UI elements
	WidgetSlider slider_num_requests;
	WidgetSlider slider_beaufort;
	WidgetSlider slider_fetch_amplitude;
	WidgetSlider slider_fetch_stepness;
	WidgetSlider slider_intersection_amplitude;
	WidgetSlider slider_intersection_stepness;
	WidgetSlider slider_precision;

	// pointer to the Global Water object
	private ObjectWaterGlobal water;

	private WidgetWindow window;
	// UI construction for parameters 
	// function creating a parameter and adding the corresponding UI element
	private WidgetSlider create_param(Widget parent, String name, float default_value, float min_value, float max_value, Func<float,int> f, bool floating)
	 {
		WidgetLabel label = new WidgetLabel(name);
		label.Width = 100;
		parent.AddChild(label, Gui.ALIGN_LEFT);

		WidgetSlider slider = new WidgetSlider();
		slider.MinValue = MathLib.ToInt(min_value * (floating ? 1000 : 1));
		slider.MaxValue = MathLib.ToInt(max_value * (floating ? 1000 : 1));
		slider.Value = MathLib.ToInt(default_value * (floating ? 1000 : 1));

		slider.Width = 200;
		slider.ButtonWidth = 20;
		slider.ButtonHeight = 20;
		parent.AddChild(slider, Gui.ALIGN_LEFT);

		label = new WidgetLabel(default_value.ToString());
		label.Width = 20;
		parent.AddChild(label);

		slider.AddCallback(Gui.CALLBACK_INDEX.CHANGED, () => 
		{
			float v = slider.Value / (floating ? 1000.0f : 1.0f);
			label.Text = v.ToString();
			f(v);
		});

		return slider;
	}
	private void Init_GUI()
	{
		window = new WidgetWindow("Fetch and Intersection Water Parameters");
		Gui.GetCurrent().AddChild(window, Gui.ALIGN_OVERLAP);

		WidgetGroupBox group_box = new WidgetGroupBox("Parameters", 8, 8);
		window.AddChild(group_box, Gui.ALIGN_LEFT);

		WidgetHBox hbox = new WidgetHBox();
		group_box.AddChild(hbox, Gui.ALIGN_LEFT);
		WidgetLabel label = new WidgetLabel("Request Type");
		label.Width = 180;
		hbox.AddChild(label, Gui.ALIGN_LEFT);

		WidgetButton fetch_b = new WidgetButton("Fetch");
		hbox.AddChild(fetch_b, Gui.ALIGN_LEFT);
		fetch_b.Toggleable = true;
		fetch_b.Toggled = fetch;
		WidgetButton intersection_b = new WidgetButton("Intersection");
		hbox.AddChild(intersection_b, Gui.ALIGN_LEFT);
		intersection_b.Toggleable = true;
		intersection_b.Toggled = !fetch;

		fetch_b.AddCallback(Gui.CALLBACK_INDEX.CHANGED, ()=>
		{
			fetch = fetch_b.Toggled;
			intersection_b.Toggled = !fetch;
		}
		);
		intersection_b.AddCallback(Gui.CALLBACK_INDEX.CHANGED, ()=>
		{
			fetch = !intersection_b.Toggled;
			fetch_b.Toggled = fetch;
		}
		);
		WidgetGridBox grid = new WidgetGridBox(3);
		group_box.AddChild(grid);
		
		// number of fetch/intersection requests slider
		slider_num_requests = create_param(grid, "Request Count", num_intersection, 100, 10000, (v) => { num_intersection = MathLib.ToInt(v); return 1;}, false);
		
		// Beaufort level slider
		slider_beaufort = create_param(grid, "Beaufort", 0, 0, 13, (v) => { water.Beaufort = v; return 1;}, true);

		for (int i = 0; i < 3; i++)
		{
			WidgetSpacer s = new WidgetSpacer();
			grid.AddChild(s);
			s.Orientation = 1;
		}
		
		// sliders controlling quality parameters for fetch requests
		slider_fetch_amplitude = create_param(grid, "Fetch Amplitude Threshold", water.FetchAmplitudeThreshold, 0.001f, 0.5f, (v) => { water.FetchAmplitudeThreshold = v; return 1;}, true);
		slider_fetch_stepness = create_param(grid, "Fetch Steepness Quality", (float) water.FetchSteepnessQuality, 0, 4, (v) => { water.FetchSteepnessQuality = (ObjectWaterGlobal.STEEPNESS_QUALITY) MathLib.RoundToInt(v); return 1;}, false);

		for (int i = 0; i < 3; i++)
		{
			WidgetSpacer s = new WidgetSpacer();
			grid.AddChild(s);
			s.Orientation = 1;
		}

		// sliders controlling quality and precision parameters for intersection requests
		slider_intersection_amplitude = create_param(grid, "Intersection Amplitude Threshold", water.IntersectionAmplitudeThreshold, 0.001f, 0.5f, (v) => { water.IntersectionAmplitudeThreshold = v; return 1;}, true);
		slider_intersection_stepness = create_param(grid, "Intersection Steepness Quality", (float) water.IntersectionSteepnessQuality, 0, 4, (v) => { water.IntersectionSteepnessQuality = (ObjectWaterGlobal.STEEPNESS_QUALITY) MathLib.RoundToInt(v); return 1;}, false);
		slider_precision = create_param(grid, "Intersection Precision", water.IntersectionPrecision, 0.01f, 2.0f, (v) => { water.IntersectionPrecision = v; return 1;}, true);
	}

	private void Shutdown_GUI()
	{
		window.DeleteLater();
	}

	private void Init()
	{
		// write here code to be called on component initialization
		water = water_node as ObjectWaterGlobal;
		Visualizer.Enabled = true;
		Init_GUI();
	}
	
	private void Update()
	{
		// calculating the number of fetch/intersection points along X and Y axes
		int count = MathLib.ToInt(MathLib.Sqrt(num_intersection));
		
		// creating an object to store intersection data
		ObjectIntersectionNormal oin = new ObjectIntersectionNormal();

		// looping over all points to perform fetch/intersection requests with the current settings 
		for (int i = 0; i < count; i++)
		{
			for (int j = 0; j < count; j++)
			{
				vec3 pos = new vec3(i, j, 0);
				if (fetch)
				{
					// getting Global Water height data  and the point and displaying it
					float v = water.FetchHeight(pos);
					pos.z += v;
					Visualizer.RenderPoint3D(pos, intersect_point_size, vec4.BLUE);

					// getting and displaying normals at fetch points
					vec3 n = water.FetchNormal(pos);
					Visualizer.RenderVector(pos, pos + new vec3(n), vec4.WHITE);
				}
				else
				{
					// getting and displaying normals at intersection points
					if (water.GetIntersection(pos + vec3.UP * 100, pos - vec3.UP * 100, oin, 0))
					{
						Visualizer.RenderPoint3D(oin.Point, intersect_point_size, vec4.GREEN);
						Visualizer.RenderVector(oin.Point, oin.Point + new vec3(oin.Normal), vec4.WHITE);
					}

				}
			}
		}
	}
	
	private void Shutdown()
	{
		Shutdown_GUI();
	}
}