Programming Quick References

// auxiliary variables for messages
string file_name = "file.txt";
int ID = 10;
			
// reporting an error message
Log.Error("Loading mesh: can't open \"{0}\" file\n", file_name);

// reporting a message
Log.Message("-> Added {0} UI elements.\n", ID);
	
// reporting a warning message
Log.Warning("ID of the \"{0}\" file: {1}.\n", file_name, ID);
	
// reporting a fatal error message to the log file and closing the application
Log.Fatal("FATAL ERROR reading \"{0}\" file!\n", file_name);

// loading world from the my_world.world file
World.LoadWorld("my_world");

// saving current world to the my_world.world file
Unigine.Console.Run("world_save my_world");

// loading world from the my_world.world file
Unigine.Console.Run("world_load my_world");

// closing the application 
App.Exit();

// creating a node of the NodeType named nodename
<NodeType> nodename = new <NodeType>(<construction_parameters>);
	
// removing the node
nodename.DeleteLater();

// link to a node asset file on disk
public AssetLinkNode assetNode;
// specify the spawn transform (position, rotation and scale)
public Node spawnPoint;

// load the node using the referenced asset
assetNode.Load(spawnPoint);

// link to an asset file on disk
public AssetLink meshAsset;
// specify the spawn transform (position, rotation and scale)
public Node spawnPoint;

// check to see if the file exists on disk
if (meshAsset.isFileExist)
{
	// create a new mesh from the asset link
	ObjectMeshStatic mesh = new ObjectMeshStatic(meshAsset.Path);
	// copy the transformation of the spawn point
	mesh.WorldTransform = spawnPoint.WorldTransform;
}

using Unigine;

namespace UnigineApp
{
	class AppWorldLogic : WorldLogic
	{
		public override bool Init()
		{
			// creating a new PlayerSpectator instance
			PlayerSpectator playerSpectator = new PlayerSpectator();

			// setting necessary parameters: FOV, ZNear, ZFar, view direction vector and position.
			playerSpectator.Fov = 90.0f;
			playerSpectator.ZNear = 0.1f;
			playerSpectator.ZFar = 10000.0f;
			playerSpectator.ViewDirection = new vec3(0.0f, 1.0f, 0.0f);
			playerSpectator.WorldPosition = new dvec3(-1.6f, -1.7f, 1.7f);

			// setting the player as a default one via the Game singleton instance
			Game.Player = playerSpectator;

			return true;
		}
	}
}

using Unigine;

namespace UnigineApp
{
	class AppWorldLogic : WorldLogic
	{
		public override bool Init()
		{
			// creating a world light source and setting its color to white
			LightWorld sun = new LightWorld(new vec4(1.0f, 1.0f, 1.0f, 1.0f));
				
			// setting light source's parameters (intensity, disable angle, scattering type, name and rotation)
			sun.Name = "Sun";
			sun.DisableAngle = 90.0f;
			sun.Intensity = 1.0f;
			sun.Scattering = LightWorld.SCATTERING.SUN;
			sun.SetWorldRotation(new quat(86.0f, 30.0f, 300.0f));
			
			return true;
		}
	}
}

using Unigine;

namespace UnigineApp
{
	class AppWorldLogic : WorldLogic
	{
		public override bool Init()
		{
			// creating a box (ObjectMeshDynamic node)
			Mesh mesh = new Mesh();
			mesh.AddBoxSurface("box_surface", new vec3(1.5f, 1.5f, 1.5f));
			ObjectMeshDynamic my_mesh = new ObjectMeshDynamic(mesh);

			// getting the base mesh_base material to inherit from
			Material mesh_base = Materials.FindMaterial("mesh_base");
			// creating a new child material of the mesh_base named "my_mesh_base0"
			Material my_mesh_base = mesh_base.Inherit("my_mesh_base0");
	
			// setting the albedo color of the material to red
			my_mesh_base.SetParameterFloat4("albedo_color", new vec4(255, 0, 0, 255));

			// assigning a "my_mesh_base0" material to the surface 0 of the my_mesh ObjectMeshDynamic node
			my_mesh.SetMaterial("my_mesh_base0", 0);
	
			// assigning a "my_mesh_base0" material to all surfaces of the my_mesh ObjectMeshDynamic node
			my_mesh.SetMaterial("my_mesh_base0", "*");

			return true;
		}
		
		public override bool Shutdown()
		{
			// deleting the material named "my_mesh_base0"
			Materials.RemoveMaterial(Materials.FindMaterial("my_mesh_base0").GUID);
			return true;
		}
	}
}

// find a pointer to node by a given name
Node baseptr = World.GetNodeByName("my_meshdynamic");

// cast a pointer-to-derived from pointer-to-base with automatic type checking
ObjectMeshDynamic derivedptr = baseptr as ObjectMeshDynamic;

// upcast to the pointer to the Object class which is a base class for ObjectMeshDynamic
Object obj = derivedptr;

// upcast to the pointer to the Node class which is a base class for all scene objects
Node node = derivedptr;

// get the component assigned to a node by type "MyComponent"
MyComponent my_component = GetComponent<MyComponent>(some_node);

// do the same by using the function of node
my_component = some_node.GetComponent<MyComponent>();

// move the node by X, Y, Z units along the corresponding axes
node.WorldPosition = node.WorldPosition + new vec3(X, Y, Z);

// move the node by one unit along the Y axis
node.WorldTranslate(0.0f, 1.0f, 0.0f);

// rotate the node around the axis (X, Y, Z) by the Alpha angle 
node.SetWorldRotation(node.GetWorldRotation() * new quat(new vec3(X, Y, Z), Alpha));

// rotate the node around X, Y, and Z axes by the corresponding angle (angle_X, angle_Y, angle_Z)
node.SetWorldRotation(node.GetWorldRotation() * new quat(angle_X, angle_Y, angle_Z));

// rotate the node by 45 degrees along the Z axis
node.WorldRotate(0.0f, 0.0f, 45.0f);

// orient the node using a direction vector and a vector pointing upwards
node.SetWorldDirection(new vec3(0.5f, 0.5f, 0.0f), vec3.UP, MathLib.AXIS.Y);

// setting node scale to Scale_X, Scale_Y, Scale_Z along the corresponding axes
node.WorldScale = new vec3(Scale_X, Scale_Y, Scale_Z);

// setting new transformation matrix to scale the node 2 times along all axes, rotate it by 45 degrees around the Z-axis and move it by 1 unit along all axes
dmat4 transform = new dmat4(MathLib.Translate(1.0f, 1.0f, 1.0f) * MathLib.Rotate(new quat(0.0f, 0.0f, 1.0f, 45.0f)) * MathLib.Scale(new vec3(2.0f)));

// setting node transformation matrix relative to its parent
node.Transform = transform;

// setting node transformation matrix relative to the world origin
node.WorldTransform = transform;

using Unigine;

namespace UnigineApp
{
	class AppWorldLogic : WorldLogic
	{
	/* .. */
		public override bool Update()
		{
			// getting an inverse FPS value (the time in seconds it took to complete the last frame)
			float ifps = Game.IFps;
	
			// moving the node up by 0.3 units every second instead of every frame
			node.WorldTranslate(new dvec3(0.0f, 0.0f, 0.3f * ifps));

			return true;
		}
	}
}

using Unigine;

namespace UnigineApp
{
	class AppWorldLogic : WorldLogic
	{

		const float INTERVAL_DURATION = 5;
		float elapsed_time = INTERVAL_DURATION;
		
		/* .. */

		public override bool Update()
		{
			
			// getting an inverse FPS value (the time in seconds it took to complete the last frame)
			float ifps = Game.IFps;

			// checking if it's time to make changes
			if (elapsed_time < 0.0f)
			{
		
				/* .. DO SOME CHANGES .. */

				// resetting elapsed time counter
				elapsed_time = INTERVAL_DURATION;
			}

			// decreasing elapsed time counter
			elapsed_time -= ifps;
	
			return true;
		}
	}
}

using System.Collections.Generic;
using Unigine;

namespace UnigineApp
{
	class AppWorldLogic : WorldLogic
	{
	/* .. */
		void listNodes(List<Node> nodes, string intersection_with)
		{
			Log.Message("total number of nodes intersecting a {0} is: {1} \n", intersection_with, nodes.Count);
			foreach (Node node in nodes)
			{
				Log.Message("Intersected node: {0} \n", node.Name);
			}

			// clearing the list of nodes
			nodes.Clear();
		}
		
		public override bool Update()
		{
			// getting a player pointer
			Player player = Game.Player;

			// creating a vector to store intersected nodes
			List<Node> nodes = new List<Node>();

			//-------------------------- FINDING INTERSECTIONS WITH A BOUNDING BOX -------------------------

			// initializing a bounding box with a size of 3 units, located at the World's origin 
			WorldBoundBox boundBox = new WorldBoundBox(new dvec3(0.0f), new dvec3(3.0f));

			// finding nodes intersecting a bounding box and listing them if any
			if (World.GetIntersection(boundBox, nodes))
				listNodes(nodes, "bounding box");

			//------------------------- FINDING INTERSECTIONS WITH A BOUNDING SPHERE ------------------------

			// initializing a bounding sphere with a radius of 3 units, located at the World's origin 
			WorldBoundSphere boundSphere = new WorldBoundSphere(new dvec3(0.0f), 3.0f);

			// finding nodes intersecting a bounding sphere and listing them if any
			if (World.GetIntersection(boundSphere, nodes)) 
				listNodes(nodes, "bounding sphere");

			//------------------------- FINDING INTERSECTIONS WITH A BOUNDING FRUSTUM -----------------------

			// initializing a bounding frustum with a  frustum of the player's camera
			WorldBoundFrustum boundFrustum = new WorldBoundFrustum(player.Camera.Projection, player.Camera.Modelview);

			// finding ObjectMeshStaticNodes intersecting a bounding frustum and listing them if any
			if (World.GetIntersection(boundFrustum, Node.TYPE.OBJECT_MESH_STATIC, nodes)) 
				listNodes(nodes, "bounding frustum");

			//---------------- FINDING THE FIRST OBJECT INTERSECTED BY A RAY CAST FROM P0 to P1 --------------

			// initializing points of the ray from player's position in the direction pointed by the mouse cursor 
			ivec2 mouse = Input.MouseCoord;
			dvec3 p0 = player.WorldPosition;
			dvec3 p1 = p0 + new dvec3(player.GetDirectionFromScreen(mouse.x, mouse.y)) * 100;

			//creating a WorldIntersection object to store the information about the intersection
			WorldIntersection intersection = new WorldIntersection();

			// casting a ray from p0 to p1 to find the first intersected object
			Object obj = World.GetIntersection(p0, p1, 1, intersection);

			// print the name of the first intersected object and coordinates of intersection point if any
			if (obj)
			{
				dvec3 p = intersection.Point;
				Log.Message("The first object intersected by the ray at point ({0}) is: {1} \n ", p, obj.Name);
			}
			return true;
		}
	}
}

using Unigine;

namespace UnigineApp
{
	class AppWorldLogic : WorldLogic
	{
	/* .. */		
		public override bool Update()
		{
			// if right mouse button is clicked
			if(Input.IsMouseButtonDown(Input.MOUSE_BUTTON.RIGHT))
			{
				ivec2 mouse = Input.MouseCoord;
				// report mouse cursor coordinates to the console
				Log.Message("Right mouse button was clicked at {0}\n", mouse);
			}

			// closing the application if a 'Q' key is pressed, ignoring the key if the console is opened
			if (Input.IsKeyDown(Input.KEY.Q) && !Console.Activity)
			{
				App.Exit();
			}
			
			return true;
		}
	}
}

using Unigine;

namespace UnigineApp
{
	class AppWorldLogic : WorldLogic
	{
/* .. */
		public override bool Update()
		{
			// if right mouse button is clicked
			if(App.ClearMouseButtonState(App.BUTTON_RIGHT) != 0)
			{
				// report mouse cursor coordinates to the console
				Log.Message("Right mouse button was clicked at {0}, {1}\n", App.GetMouseX(), App.GetMouseY());
			}

			// closing the application if a 'Q' key is pressed, ignoring the key if the console is opened
			if (App.GetKeyState('q') != 0 && !Console.Activity)
			{
				App.Exit();
			}

			return true;
		}
	}
}

using Unigine;

namespace UnigineApp
{
	class AppWorldLogic : WorldLogic
	{
/* .. */
		public override bool Update()
		{
	// getting current controls
	Controls controls = Game.Player.Controls;

	// checking controls states and reporting which buttons were pressed
	if (controls.ClearState(Controls.STATE_FORWARD) != 0 || controls.ClearState(Controls.STATE_TURN_UP) != 0)
	{
		Log.Message("FORWARD or UP key pressed\n");
	}
	else if (controls.ClearState(Controls.STATE_BACKWARD) != 0  || controls.ClearState(Controls.STATE_TURN_DOWN) != 0 )
	{
		Log.Message("BACKWARD or DOWN key pressed\n");
	}
	else if (controls.ClearState(Controls.STATE_MOVE_LEFT) != 0  || controls.ClearState(Controls.STATE_TURN_LEFT) != 0 )
	{
		Log.Message("MOVE_LEFT or TURN_LEFT key pressed\n");
	}
	else if (controls.ClearState(Controls.STATE_MOVE_RIGHT) != 0  || controls.ClearState(Controls.STATE_TURN_RIGHT) != 0 )
	{
		Log.Message("MOVE_RIGHT or TURN_RIGHT key pressed\n");
	}

			return true;
		}
	}
}

using Unigine;

namespace UnigineApp
{
	class AppWorldLogic : WorldLogic
	{
/* .. */

		public override bool Init()
		{
			// remapping states to other keys and buttons
			ControlsApp.SetStateKey(Controls.STATE_FORWARD, App.KEY_PGUP);
			ControlsApp.SetStateKey(Controls.STATE_BACKWARD, App.KEY_PGDOWN);
			ControlsApp.SetStateKey(Controls.STATE_MOVE_LEFT, 'l');
			ControlsApp.SetStateKey(Controls.STATE_MOVE_RIGHT, 'r');
			ControlsApp.SetStateButton(Controls.STATE_JUMP, App.BUTTON_LEFT);
			return true;
		}
		public override bool Update()
		{
			if (ControlsApp.ClearState(Controls.STATE_FORWARD) != 0)
			{
				Log.Message("FORWARD key pressed\n");
			}
			else if (ControlsApp.ClearState(Controls.STATE_BACKWARD) != 0)
			{
				Log.Message("BACKWARD key pressed\n");
			}
			else if (ControlsApp.ClearState(Controls.STATE_MOVE_LEFT) != 0)
			{
				Log.Message("MOVE_LEFT key pressed\n");
			}
			else if (ControlsApp.ClearState(Controls.STATE_MOVE_RIGHT) != 0)
			{
				Log.Message("MOVE_RIGHT key pressed\n");
			}
			else if (ControlsApp.ClearState(Controls.STATE_JUMP) != 0)
			{
				Log.Message("JUMP button pressed\n");
			}
			return true;
		}
	}
}

using Unigine;

namespace UnigineApp
{
	class AppWorldLogic : WorldLogic
	{

		public override bool Init()
		{
			// getting a GUI pointer
			Gui gui = Gui.Get();

			// creating a label widget and setting up its parameters
			WidgetLabel widget_label = new WidgetLabel(gui, "Label text:");
			widget_label.SetToolTip("This is my label!");
			widget_label.Arrange();
			widget_label.SetPosition(10, 10);

			// creating a slider widget and setting up its parameters
			WidgetSlider widget_slider = new WidgetSlider(gui, 0, 360, 90);
			widget_slider.SetToolTip("This is my slider!");
			widget_slider.Arrange();
			widget_slider.SetPosition(100, 10);

			gui.AddChild(widget_label, Gui.ALIGN_OVERLAP | Gui.ALIGN_FIXED);
			gui.AddChild(widget_slider, Gui.ALIGN_OVERLAP | Gui.ALIGN_FIXED);

			return true;
		}
	}
}

using Unigine;

namespace UnigineApp
{
	class AppWorldLogic : WorldLogic
	{

		void onSliderChanged(Widget sender)
		{
			Log.Message("\n The value of the slider has been changed: {0}\n", (sender as WidgetSlider).Value);
		}

		public override bool Init()
		{
			// getting the system GUI
			Gui gui = Gui.Get();

			// creating a button widget and setting its parameters
			WidgetButton widget_button = new WidgetButton(gui, "Press me");
			widget_button.Arrange();
			widget_button.SetPosition(10,10);
			
			// creating a slider widget and setting its parameters
			WidgetSlider widget_slider = new WidgetSlider(gui);
			widget_button.Arrange();
			widget_button.SetPosition(100,10);

			// setting a lambda function to handle CLICKED event
			widget_button.AddCallback(Gui.CALLBACK_INDEX.CLICKED, () => Log.Message("Button pressed\n"));
			// setting a method to handle CHANGED event
			widget_slider.AddCallback(Gui.CALLBACK_INDEX.CHANGED, onSliderChanged);

			// adding the created widgets to the system GUI
			gui.AddChild(widget_button, Gui.ALIGN_OVERLAP | Gui.ALIGN_FIXED);
			gui.AddChild(widget_slider, Gui.ALIGN_OVERLAP | Gui.ALIGN_FIXED);
			
			return true;
		}
	}
}

// create a mesh box
Mesh meshBox = new Mesh();
meshBox.AddBoxSurface("box_surface", new vec3(1.0f));
ObjectMeshStatic box = new ObjectMeshStatic(meshBox);

// create a body and a shape based on the mesh
BodyRigid bodyBox = new BodyRigid(box);
ShapeBox shapeBox = new ShapeBox(bodyBox, new vec3(1.0f));

using Unigine;

namespace UnigineApp
{
	class AppWorldLogic : WorldLogic
	{	
		// implement the enter callback
        void enter_callback(Node node)
        {
			Log.Message("\nA node named {0} has entered the trigger\n", node.Name);
        }

        // implement the leave callback
        void leave_callback(Node node)
        {
	        Log.Message("\nA node named {0} has left the trigger\n", node.getName());
        }

		WorldTrigger trigger;
		
        public override bool Init()
        {
            // create a world trigger
            trigger = new WorldTrigger(new vec3(3.0f));
            // add the enter callback to be fired when a node enters the world trigger
            trigger.AddEnterCallback(enter_callback);
            // add the leave callback to be fired when a node leaves the world trigger
            trigger.AddLeaveCallback(leave_callback);

            return true;
        }
	}
}