This page has been translated automatically.
Video Tutorials
Interface
Essentials
Advanced
How To
UnigineEditor
Interface Overview
Assets Workflow
Settings and Preferences
Working With Projects
Adjusting Node Parameters
Setting Up Materials
Setting Up Properties
Lighting
Landscape Tool
Sandworm
Using Editor Tools for Specific Tasks
Extending Editor Functionality
Built-in Node Types
Nodes
Objects
Effects
Decals
Light Sources
Geodetics
World Nodes
Sound Objects
Pathfinding Objects
Players
Programming
Fundamentals
Setting Up Development Environment
Usage Examples
C++
UnigineScript
UUSL (Unified UNIGINE Shader Language)
Plugins
File Formats
Rebuilding the Engine Tools
GUI
Double Precision Coordinates
API
Containers
Common Functionality
Controls-Related Classes
Engine-Related Classes
Filesystem Functionality
GUI-Related Classes
Math Functionality
Node-Related Classes
Objects-Related Classes
Networking Functionality
Pathfinding-Related Classes
Physics-Related Classes
Plugins-Related Classes
IG Plugin
CIGIConnector Plugin
Rendering-Related Classes
Content Creation
Content Optimization
Materials
Material Nodes Library
Miscellaneous
Input
Math
Matrix
Textures
Art Samples
Tutorials
Warning! This version of documentation is OUTDATED, as it describes an older SDK version! Please switch to the documentation for the latest SDK version.
Warning! This version of documentation describes an old SDK version which is no longer supported! Please upgrade to the latest SDK version.

Plugin Class

You can get access to the main loop of the Unigine engine by overriding virtual methods of the Unigine.Plugin class. This article describes the sample located in the <UnigineSDK>/source/csharp/samples/Api/Systems/Ffp/ directory.

Notice
In the C# API you can inherit from the Plugin class only once.

See also#

  • An example can be found in the <UnigineSDK>/source/csharp/samples/Api/Systems/Ffp/ directory.
  • C++ API classes Unigine::Plugin and Unigine::Ffp which have the same methods and behavior as in the C# API.

Plugin Class Usage Example#

C# Side#

To use the Unigine.Plugin class, you should create your own class and inherit it from the Unigine.Plugin class and override necessary methods, which the engine will perform in its main loop.

Source code (C#)
using System;
using Unigine;

/*
 */
class UnigineApp {
	
	/*
	 */
	class FfpPlugin : Plugin {
		
		private float time;
		
		public override void gui() {
			time += Engine.ifps;
			render(time);
		}
		
		private void render(float time) {
			
			App app = Engine.app;
			Ffp ffp = Engine.ffp;
			
			// screen size
			int width = app.GetWidth();
			int height = app.GetHeight();
			float radius = height / 2.0f;
			
			ffp.Enable(Ffp.MODE_SOLID);
			ffp.SetOrtho(width,height);
				
				// begin triangles
				ffp.BeginTriangles();
				
				// vertex colors
				uint[] colors = { 0xffff0000, 0xff00ff00, 0xff0000ff };
				
				// create vertices
				int num_vertex = 16;
				for(int i = 0; i < num_vertex; i++) {
					float angle = MathLib.PI2 * i / (num_vertex - 1) - time;
					float x = width / 2 + (float)Math.Sin(angle) * radius;
					float y = height / 2 + (float)Math.Cos(angle) * radius;
					ffp.AddVertex(x,y);
					ffp.SetColor(colors[i % 3]);
				}
				
				// create indices
				for(int i = 1; i < num_vertex; i++) {
					ffp.AddIndex(0);
					ffp.AddIndex(i);
					ffp.AddIndex(i - 1);
				}
				
				// end triangles
				ffp.EndTriangles();
				
			ffp.Disable();
		}
	}
	
	/*
	 */
	[STAThread]
	static void Main(string[] args) {
		
		// initialize engine
		Engine engine = Engine.Init(Engine.VERSION,args);
		
		// create plugin
		FfpPlugin plugin = new FfpPlugin();
		engine.AddPlugin(plugin);
		
		// enter main loop
		engine.Main();
		
		// remove plugin
		engine.RemovePlugin(plugin);
		
		// shutdown engine
		Engine.Shutdown();
	}
}

In this part of the code we create the FfpPlugin class which inherits the Plugin class and override the gui() method. We specified the render() method and call it inside the overridden gui() method. Engine calls this function before gui each render frame.

In the Main() method, we create an instance of the FfpPlugin class and add it to the engine by using the AddPlugin() method after the engine had been initialized.

Unigine Script Side#

All the logic is implemented in the C# Ffp.cs file. There is only one command in the UnigineScript ffp.cpp file to show a console:

Source code (UnigineScript)
int init() {
		
	// show console
	engine.console.setActivity(1);

	return 1;
}

Output#

The following result will be shown:

Last update: 2021-12-13
Build: ()