从Unity迁移到UNIGINE：编程

Game logic in a Unity project is implemented via Script components. You got used to determine GameObject's behavior by writing event functions like Start(), Update(), etc.Unity项目中的游戏逻辑是通过脚本组件实现的。您习惯于通过编写事件函数（例如Start(), Update()等）来确定GameObject的行为。

UNIGINE has quite a similar concept, which can be easily adopted — C# Component System, which is safe and secure and ensures high performance. Logic is written in C# components that can be assigned to any node in the scene. Each component has a set of functions (Init(), Update(), etc.), that are called by the corresponding functions of the engine main loop.UNIGINE的概念非常相似，可以很容易地采用- C＃组件系统，这是安全可靠的，并确保了高性能。逻辑用C＃组件编写，可以分配给场景中的任何节点。每个组件都有一组功能（Init(), Update()等），这些功能由引擎的相应功能调用主循环。

Programming in UNIGINE using C# is not much different from programming in Unity software. For example, let's compare how rotation is performed in Unity software:使用C＃在UNIGINE中进行编程与在Unity软件中进行编程没有太大区别。例如，让我们比较一下在Unity软件中如何执行旋转：

using UnityEngine;

public class MyComponent : MonoBehaviour
{
    public float speed = 90.0f;

    void Update()
    {
        transform.Rotate(0, speed * Time.deltaTime, 0, Space.Self);
    }
}

and in UNIGINE:在UNIGINE中：

using Unigine;
/* .. */
public class MyComponent : Component
{
	public float speed = 90.0f;
	
	void Update()
	{
		node.Rotate(0, 0, speed * Game.IFps);
	}
}

The Run button is available in the Editor to run an instance of the application in a separate window. Along with the button, there are settings available to fine-tune run options.在编辑器中可以使用Run按钮来运行应用程序的实例在一个单独的窗口中。除按钮外，还有一些设置可用于微调运行选项。

That's how we'll make the wheel rotate using C# Component System and run an instance to immediately check it:这就是我们使用C＃组件系统使轮子旋转并运行实例以立即对其进行检查的方式：

Moreover in UNIGINE, you can also implement Application Logic for the whole application by writing code in the AppWorldLogic.cs, AppSystemLogic.cs and AppEditorLogic.cs files stored in the source/ project folder.此外，在UNIGINE中，您还可以实现应用逻辑通过在存储在source/项目文件夹中的AppWorldLogic.cs，AppSystemLogic.cs和AppEditorLogic.cs文件中编写代码来实现整个应用程序。

To learn more about the execution sequence and how to build components, follow the links below:要了解有关执行顺序以及如何构建组件的更多信息，请单击下面的链接：

• Execution Sequence执行顺序
• Video tutorial on C# Component System有关C＃组件系统的视频教程

For those who prefer C++, UNIGINE allows creating C++ applications using C++ API and, if required, C++ Component System.对于那些喜欢C ++的人，UNIGINE允许创建C ++应用程序使用C ++ API，如果需要， C ++组件系统。

Printing to Console打印到控制台#

Debug.Log("Text: " + text);
Debug.LogFormat("Formatted text: {0}", text);

Log.Message("Debug info:" + text + "\n");
Log.Message("Debug info: {0}\n", new vec3(1, 2, 3));

Accessing the GameObject / Node from Component从组件访问GameObject / Node#

GameObject this_go = gameObject;
string n = gameObject.name;

Node this_node = node;
string n = node.Name;

Working with Directions指导工作#

In Unity software to get a vector on a certain axis while also considering the rotation of a game object in world coordinates, you use the corresponding properties of the Transform component. The same vector in UNIGINE is got by using Node.GetWorldDirection() function:在Unity软件中，要获取某个轴上的向量，同时还要考虑游戏对象在世界坐标中的旋转，您可以使用Transform组件的相应属性。通过使用Node.GetWorldDirection()函数，可以在UNIGINE中获得相同的向量：

Unity software	UNIGINE
源代码 (C#) Vector3 forward = transform.forward; Vector3 right = transform.right; Vector3 up = transform.up; transform.Translate(forward * speed * Time.deltaTime);	源代码 (C#) vec3 forward = node.GetWorldDirection(MathLib.AXIS.Y); vec3 right = node.GetWorldDirection(MathLib.AXIS.X); vec3 up = node.GetWorldDirection(MathLib.AXIS.Z); node.Translate(forward * speed * Game.IFps);

注意

Intances of the Players-Related classes use different direction vectors and are to be treated correspondingly.的实例玩家相关课程使用不同的方向向量，将被对待相应地。

See Also也可以看看#

• Coordinate System in UNIGINE坐标系在UNIGINE中

Smoother Gameplay with DeltaTime / IFpsDeltaTime / IFps使游戏玩法更流畅#

transform.Rotate(0, speed * Time.deltaTime, 0, Space.Self);

node.Rotate(0, 0, speed * Game.IFps);

Drawing Debug Data绘图调试数据#

Unity software:Unity软件：

源代码 (C#)

Debug.DrawLine(Vector3.zero, new Vector3(5, 0, 0), Color.white, 2.5f);

Vector3 forward = transform.TransformDirection(Vector3.forward) * 10;
Debug.DrawRay(transform.position, forward, Color.green);

UNIGINE:

源代码 (C#)

Visualizer.Enabled = true;

/*..*/

Visualizer.RenderLine3D(vec3.ZERO, new vec3(5, 0, 0), vec4.ONE);
Visualizer.RenderVector(node.Position, node.GetDirection(MathLib.AXIS.Y) * 10, new vec4(1, 0, 0, 1));

注意

The visualizer can be toggled on and off via show_visualizer 1 console command as well.可视化工具也可以通过show_visualizer 1控制台命令打开和关闭。

See Also也可以看看#

• More types of visualizations in the Visualizer class API.Visualizer类API中的更多可视化类型。

Loading a Scene加载场景#

SceneManager.LoadScene("YourSceneName",LoadSceneMode.Single);

World.LoadWorld("YourSceneName");

Accessing a Component from the GameObject / Node从GameObject/Node访问组件#

MyComponent my_component = gameObject.GetComponent<MyComponent>();

MyComponent my_component = node.GetComponent<MyComponent>();
MyComponent my_component = GetComponent<MyComponent>(node);

// accessing the transform of the game object
Transform transform_1 = gameObject.GetComponent<Transform>();
Transform transform_2 = gameObject.transform;

// accessing the Mesh Renderer component
MeshRenderer mesh_renderer = gameObject.GetComponent<MeshRenderer>();

// accessing the Rigidbody component
Rigidbody rigidbody = gameObject.GetComponent<Rigidbody>();

// accessing a collider
Collider collider = gameObject.GetComponent<Collider>();
BoxCollider boxCollider = collider as BoxCollider;

// getting the transformation matrix of the node
mat4 transform = node.WorldTransform;

// downcasting the node to the ObjectMeshStatic class
ObjectMeshStatic mesh_static = node as ObjectMeshStatic;

// accessing the rigid body assigned to the node
Body body = (node as Unigine.Object).Body;
BodyRigid rigid = body as BodyRigid;

// fetch all collision shapes of the ShapeBox type
for (int i = 0; i < body.NumShapes; i++)
{
	Shape shape = body.GetShape(i);
	if (shape is ShapeBox)
	{
		ShapeBox shape_box = shape as ShapeBox;
		...
	}
}

Finding GameObjects / Nodes查找GameObject/Node#

// Find a GameObject by name
GameObject myGameObj = GameObject.Find("My Game Object");

// Find the child named "ammo" of the gameobject "magazine" (magazine is a child of "gun").
Transform ammo_transform = gameObject.transform.Find("magazine/ammo");
GameObject ammo = ammo_transform.gameObject;

// Find GameObjects by the type of component assigned
MyComponent[] components = Object.FindObjectsOfType<MyComponent>();
foreach (MyComponent component in components)
{
        // ...
}

// Find GameObjects by tag
GameObject[] taggedGameObjects = GameObject.FindGameObjectsWithTag("MyTag");
foreach (GameObject gameObj in taggedGameObjects)
{
        // ...
}

// Find a Node by name
Node my_node = World.GetNodeByName("my_node");

// Find all nodes having this name
List<Node> nodes = new List<Node>();
World.GetNodesByName("my_node");

// Find the index of a direct child node
int index = node.FindChild("child_node");
Node direct_child = node.GetChild(index);

// Perform a recursive descend down the hierarchy to find a child Node by name
Node child = node.FindNode("child_node", 1);

// Find Nodes by the type of component assigned
MyComponent[] my_comps = FindComponentsInWorld<MyComponent>();
foreach(MyComponent comp in my_comps)
{
	Log.Message("{0}\n",comp.node.name);
}

Casting From Type to Type从类型到类型的转换#

Collider collider = gameObject.GetComponent<Collider>;
BoxCollider boxCollider = collider as BoxCollider;

Node node = World.GetNodeByName("my_mesh");
ObjectMeshStatic mesh = node as ObjectMeshStatic;

Collider collider = gameObject.GetComponent<Collider>;
BoxCollider boxCollider = collider as BoxCollider;
Collider coll = boxCollider;

Node node = World.GetNodeByName("my_mesh");
ObjectMeshStatic mesh = node as ObjectMeshStatic;
Unigine.Object obj = mesh;

Destroy GameObject/Node销毁GameObject / Node#

Destroy(maGameObject);

// destroy the game object with 1 second delay
Destroy(maGameObject, 1);

node.DeleteLater(); // recommended option
//called between the current and the next frames

node.DeleteForce(); // called during the same frame but unsafe

// LifetimeController.cs

/* .. */
public class LifetimeController : Component
{
	public float lifetime = 5.0f;

	void Update()
	{
		lifetime = lifetime - Game.IFps;
        if (lifetime < 0)
        {
            // destroy current node with its properties and components
			node.DeleteLater();
        }
	}
}

// MyComponent.cs

/* .. */
public class MyComponent : Component
{
	
	void Update()
	{
		if (/* a reason to die */)
		{
			LifetimeController lc = node.AddComponent<LifetimeController>();
			lc.lifetime = 2.0f;
		}
	}
}

Instantiating Prefab / Node Reference实例化prefab/NodeReference#

using UnityEngine;

public class MyComponent : MonoBehaviour
{
public GameObject myPrefab;

void Start()
{
	Instantiate(myPrefab, new Vector3(0, 0, 0), Quaternion.identity);
}
}

/* .. */
public class MyComponent : Component
{
	public AssetLinkNode node_to_spawn;
	
	private void Init()
	{
		Node spawned = node_to_spawn.Load(node.WorldPosition, quat.IDENTITY);

		Node spawned_manually = World.LoadNode("nodes/node_reference.node");
	}
}

/* .. */
public class MyComponent : Component
{
	void Init()
	{
		NodeReference nodeRef = new NodeReference("nodes/node_reference_0.node");
	}
}

You are likely to be accustomed that Unity software enables you to extend the Editor using C# scripts. For this purpose you can use special attributes in your scripts:您可能已经习惯了Unity软件使您能够使用C＃脚本扩展编辑器。为此，您可以在脚本中使用特殊属性：

• [ExecuteInEditMode] — to execute the script logic during Edit mode, while your application is not running.[ExecuteInEditMode] —在应用程序未运行时在Edit模式下执行脚本逻辑。
• [ExecuteAlways] — to execute the script logic both as part of Play mode and when editing.[ExecuteAlways] —在Play模式下和在编辑时都执行脚本逻辑。

For example, this is how you write a component that makes GameObject orient towards the certain point in the scene:例如，这是您编写使GameObject朝向场景中特定点定向的组件的方式：

//C# Example (LookAtPoint.cs)
using UnityEngine;
[ExecuteInEditMode]
public class LookAtPoint : MonoBehaviour
{
    public Vector3 lookAtPoint = Vector3.zero;

    void Update()
    {
        transform.LookAt(lookAtPoint);
    }
}

UNIGINE doesn't support executing C# logic inside the Editor. The most common way to extend functionality of UnigineEditor is C++ plugin.UNIGINE不支持在编辑器中执行C＃逻辑。相反，您可以在UnigineScript中编写逻辑以优化项目创建过程。 UnigineScript可用于您为项目选择的任何编程工作流程，包括C# .NET。

There are two methods to add a script to the project:有两种方法向项目添加脚本：

• By creating a World script. Perform the following steps:通过创建一个World脚本。执行以下步骤：

  1. Create a .usc script asset.

     

     创建一个.usc脚本资产。

     

  2. Write logic. If necessary, add a condition checking if the Editor is loaded:写逻辑。如有必要，添加条件检查是否已加载编辑器：

     源代码 (UnigineScript)

     #include <core/unigine.h>
     vec3 lookAtPoint = vec3_zero;
     Node node;
     int init() {
     	node = engine.world.getNodeByName("material_ball");
     	return 1;
     }
     
     int update() {
     	if(engine.editor.isLoaded())
     		node.worldLookAt(lookAtPoint);
     	return 1;
     }

  3. Select the current world and specify the world script for it. Click Apply and reload the world.选择当前世界并为其指定世界脚本。单击Apply并重新加载世界。

     

  4. Check the Console window for errors.检查Console窗口是否有错误。

  After that the script logic will be executed in both Editor and application.之后，脚本逻辑将在编辑器和应用程序中执行。

• By using WorldExpression. For the same purpose you can use a built-in WorldExpression node executing scripts when added to the world:通过使用WorldExpression 。出于相同的目的，您可以使用内置的WorldExpression节点添加到世界上时执行脚本：

  1. Click Create -> Logic -> Expression and place the new WorldExpression node in the world.单击Create -> Logic -> Expression，然后将新的WorldExpression节点放置在世界中。

  2. Write logic in UnigineScript in the Source field:在Source字段的UnigineScript中写入逻辑：

     源代码 (UnigineScript)

     {
     vec3 lookAtPoint = vec3_zero;
     Node node = engine.world.getNodeByName("my_node");
     node.worldLookAt(lookAtPoint);
     }

  3. Check the Console window for errors.检查Console窗口是否有错误。
  4. The logic will be executed immediately.该逻辑将立即执行。

In addition to collision detection, Unity Collider component is accountable for being Trigger that is executed when one collider enters the space of another.除碰撞检测外，Unity Collider组件还应负责当一个撞机进入另一个撞机的空间时执行的Trigger。

public class MyComponent : MonoBehaviour
{
    void Start()
    {
        collider.isTrigger = true;
    }
    void OnTriggerEnter(Collider other)
    {
        // ...
    }
    void OnTriggerExit(Collider other)
    {
        // ...
    }
}

In UNIGINE, Trigger is a special built-in node that raises events in certain situations:在UNIGINE中，Trigger是一个特殊的内置节点，在某些情况下会引发事件：

• NodeTrigger fires callbacks when the Trigger node is enabled or the Trigger node position has changed.当Trigger节点为已启用或Trigger节点位置已更改时，NodeTrigger将运行回调函数。
• WorldTrigger fires callbacks when any node (collider or not) gets inside or outside of it.WorldTrigger在任何节点（是否发生碰撞）时触发回调里面或者外部它的。

• PhysicalTrigger fires callbacks when physical objects get inside or outside of it.PhysicalTrigger在物理对象获取时触发回调里面或者外部它的。

  注意

  PhysicalTrigger does not handle collision events, for that purpose Bodies and Joints provide their own events.为此，PhysicalTrigger不处理碰撞事件身体和关节提供自己的事件。

WorldTriger is the most common type that can be used in gameplay. Here is an example on how to use it:WorldTriger是可用于游戏中的最常见类型。这是有关如何使用它的示例：

/* .. */
class MyComponent : Component
{
	WorldTrigger trigger;

	void enter_callback(Node incomer)
	{
		Log.Message("\n{0} has entered the trigger space\n", incomer.Name);
	}

	void Init()
	{
		trigger = node as WorldTrigger;
		if(trigger != null)
		{
			trigger.AddEnterCallback(enter_callback);
			trigger.AddLeaveCallback( leaver => Log.Message("{0} has left the trigger space", leaver.Name));
		}
	}
}

Unity Conventional Game Input:Unity常规游戏输入：

public class MyPlayerController : MonoBehaviour
{
    void Update()
    {
        if (Input.GetButtonDown("Fire"))
        {
            // ...
        }
        float horizontal = Input.GetAxis("Horizontal");
        float vertical = Input.GetAxis("Vertical");
        // ...
    }
}

UNIGINE:

/* .. */
class MyPlayerController : Component
{
    void Update()
    {
		if(Input.IsMouseButtonDown(Input.MOUSE_BUTTON.LEFT))
		{
			Log.Message("Left mouse button was clicked at {0}\n", Input.MousePosition);
		}

		if (Input.IsKeyDown(Input.KEY.Q) && !Unigine.Console.Activity)
		{
			Log.Message("Q was pressed and the Console is not active.\n");
			Engine.Quit();
		}
    }
}

You can also use the ControlsApp class to handle control bindings. To configure the bindings, open the Controls settings:您也可以使用ControlsApp类来处理控件绑定。要配置绑定，请打开Controls设置：

/* .. */
class MyPlayerController : Component
{
    void Init()
	{
		// remapping states to keys and buttons
		ControlsApp.SetStateKey(Controls.STATE_FORWARD, 'w');
		ControlsApp.SetStateKey(Controls.STATE_BACKWARD, 's');
		ControlsApp.SetStateKey(Controls.STATE_MOVE_LEFT, 'a');
		ControlsApp.SetStateKey(Controls.STATE_MOVE_RIGHT, 'd');
		ControlsApp.SetStateButton(Controls.STATE_JUMP, App.BUTTON_LEFT);
	}
	void 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");
		}
	}
}

In Unity software, Physics.Raycast is used. GameObject should have a Collider component attached to take part in raycasting:在Unity软件中，使用Physics.Raycast。 GameObject应该附加一个Collider组件才能参与光线投射：

using UnityEngine;
public class ExampleClass : MonoBehaviour
{
	public Camera camera;

    void Update()
    {
    	// ignore the 2nd layer
        int layerMask = 1 << 2;
        layerMask = ~layerMask;

        RaycastHit hit;
        Ray ray = camera.ScreenPointToRay(Input.mousePosition);
        if (Physics.Raycast(ray, out hit, Mathf.Infinity, layerMask))
        {
            Debug.DrawRay(transform.position, transform.TransformDirection(Vector3.forward) * hit.distance, Color.yellow);
            Debug.Log("Did Hit");
        }
        else
        {
            Debug.DrawRay(transform.position, transform.TransformDirection(Vector3.forward) * 1000, Color.white);
            Debug.Log("Did not Hit");
        }
    }
}

In UNIGINE the same is handled by Intersections:在UNIGINE中，相同的处理方式为交叉口：

/* .. */
class IntersectionExample : Component
{
	void Init()
	{
		Visualizer.Enabled = true;
	}
	void Update()
	{
		ivec2 mouse = Input.MousePosition;
		float length = 100.0f;
		vec3 start = Game.Player.WorldPosition;
		vec3 end = start + new vec3(Game.Player.GetDirectionFromMainWindow(mouse.x, mouse.y)) * length;

		// ignore surfaces that have certain bits of the Intersection mask enabled
		int mask = ~(1 << 2 | 1 << 4);

		WorldIntersectionNormal intersection = new WorldIntersectionNormal();

		Unigine.Object obj = World.GetIntersection(start, end, mask, intersection);

		if (obj)
		{
			vec3 point = intersection.Point;
			vec3 normal = intersection.Normal;
			Visualizer.RenderVector(point, point + normal, vec4.ONE);
			Log.Message("Hit {0} at {1}\n", obj.Name, point);
		}
	}
}