This page has been translated automatically.
视频教程
界面
要领
高级
实用建议
专业(SIM)
UnigineEditor
界面概述
资源工作流程
版本控制
设置和首选项
项目开发
调整节点参数
Setting Up Materials
设置属性
照明
Sandworm
使用编辑器工具执行特定任务
如何擴展編輯器功能
嵌入式节点类型
Nodes
Objects
Effects
Decals
光源
Geodetics
World Nodes
Sound Objects
Pathfinding Objects
Players
编程
基本原理
搭建开发环境
使用范例
C++
C#
UnigineScript
UUSL (Unified UNIGINE Shader Language)
Plugins
File Formats
材质和着色器
Rebuilding the Engine Tools
GUI
VR Development
双精度坐标
应用程序接口
Animations-Related Classes
Containers
Common Functionality
Controls-Related Classes
Engine-Related Classes
Filesystem Functionality
GUI-Related Classes
Math Functionality
Node-Related Classes
Networking Functionality
Pathfinding-Related Classes
Physics-Related Classes
Plugins-Related Classes
IG Plugin
CIGIConnector Plugin
Rendering-Related Classes
VR-Related Classes
创建内容
内容优化
材质
Material Nodes Library
Miscellaneous
Input
Math
Matrix
Textures
Art Samples
Tutorials

Unigine::LandscapeMapFileCreator Class

Header: #include <UnigineObjects.h>

This class is used to generate a landscape map file (.lmap) to be used for landscape layer map creation.

Usage Example#

Source code (C++)
// callbacks to be fired in the process of landscape map file creation
void progress(LandscapeMapFileCreatorPtr creator)
{
	Log::message("%d %f\n", int(creator->getProgress()), creator->getTimeSeconds());
}
void begin(LandscapeMapFileCreatorPtr creator)
{
	Log::message("%f\n", creator->getProgress());
}
void end(LandscapeMapFileCreatorPtr creator)
{
	Log::message("%f\n", creator->getTimeSeconds());
}

// ...

// defining grid size (2х2 tiles) and resolution 
ivec2 grid = ivec2(2,2);
ivec2 resolution = ivec2(2048) * grid;

// creating a landscape map file creator and setting grid size, resolution, and path
creator = LandscapeMapFileCreator::create();
creator->setGrid(grid);
creator->setResolution(resolution);
creator->setPath("test.lmap");

// adding necessary callbacks
creator->addCreateCallback(MakeCallback(&create));
creator->addProgressCallback(MakeCallback(&progress));
creator->addBeginCallback(MakeCallback(&begin));
creator->addEndCallback(MakeCallback(&end));

// running the creator to generate a new "test.lmap" file
creator->run();

// ...

// creating a new landscape layer map based on the created "test.lmap" file
landscape_map = LandscapeLayerMap::create();
landscape_map->setPath("test.lmap");

LandscapeMapFileCreator Class

Members

getProgress() const#

Returns the current Current landscape map file creation progress (percentage).

Return value

Current

getTimeSeconds() const#

Returns the current Landscape map file creation time, in seconds.

Return value

Current

Event<const Ptr<LandscapeMapFileCreator> &> getEventEnd() const#

Event triggered on completion of the landscape map file creation. The signature of the callback function must be as follows:
Source code (C++)
void end_event_handler(const Ptr<LandscapeMapFileCreator> & creator)
You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the End event handler
void end_event_handler(const Ptr<LandscapeMapFileCreator> & creator)
{
	Log::message("\Handling End event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections end_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
landscapemapfilecreator->getEventEnd().connect(end_event_connections, end_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
landscapemapfilecreator->getEventEnd().connect(end_event_connections, [](const Ptr<LandscapeMapFileCreator> & creator) { 
		Log::message("\Handling End event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
end_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection end_event_connection;

// subscribe for the End event with a handler function keeping the connection
landscapemapfilecreator->getEventEnd().connect(end_event_connection, end_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
end_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
end_event_connection.setEnabled(true);

// ...

// remove subscription for the End event via the connection
end_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A End event handler implemented as a class member
	void event_handler(const Ptr<LandscapeMapFileCreator> & creator)
	{
		Log::message("\Handling End event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
landscapemapfilecreator->getEventEnd().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the End event with a handler function
landscapemapfilecreator->getEventEnd().connect(end_event_handler);


// remove subscription for the End event later by the handler function
landscapemapfilecreator->getEventEnd().disconnect(end_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId end_handler_id;

// subscribe for the End event with a lambda handler function and keeping connection ID
end_handler_id = landscapemapfilecreator->getEventEnd().connect([](const Ptr<LandscapeMapFileCreator> & creator) { 
		Log::message("\Handling End event (lambda).\n");
	}
);

// remove the subscription later using the ID
landscapemapfilecreator->getEventEnd().disconnect(end_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all End events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
landscapemapfilecreator->getEventEnd().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
landscapemapfilecreator->getEventEnd().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler(const Ptr<LandscapeMapFileCreator> & creator)

Return value

Current

Event<const Ptr<LandscapeMapFileCreator> &> getEventBegin() const#

Event triggered at the beginning the landscape map file creation. The signature of the callback function must be as follows:
Source code (C++)
void begin_event_handler(const Ptr<LandscapeMapFileCreator> & creator)
You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the Begin event handler
void begin_event_handler(const Ptr<LandscapeMapFileCreator> & creator)
{
	Log::message("\Handling Begin event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections begin_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
landscapemapfilecreator->getEventBegin().connect(begin_event_connections, begin_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
landscapemapfilecreator->getEventBegin().connect(begin_event_connections, [](const Ptr<LandscapeMapFileCreator> & creator) { 
		Log::message("\Handling Begin event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
begin_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection begin_event_connection;

// subscribe for the Begin event with a handler function keeping the connection
landscapemapfilecreator->getEventBegin().connect(begin_event_connection, begin_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
begin_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
begin_event_connection.setEnabled(true);

// ...

// remove subscription for the Begin event via the connection
begin_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A Begin event handler implemented as a class member
	void event_handler(const Ptr<LandscapeMapFileCreator> & creator)
	{
		Log::message("\Handling Begin event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
landscapemapfilecreator->getEventBegin().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the Begin event with a handler function
landscapemapfilecreator->getEventBegin().connect(begin_event_handler);


// remove subscription for the Begin event later by the handler function
landscapemapfilecreator->getEventBegin().disconnect(begin_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId begin_handler_id;

// subscribe for the Begin event with a lambda handler function and keeping connection ID
begin_handler_id = landscapemapfilecreator->getEventBegin().connect([](const Ptr<LandscapeMapFileCreator> & creator) { 
		Log::message("\Handling Begin event (lambda).\n");
	}
);

// remove the subscription later using the ID
landscapemapfilecreator->getEventBegin().disconnect(begin_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all Begin events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
landscapemapfilecreator->getEventBegin().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
landscapemapfilecreator->getEventBegin().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler(const Ptr<LandscapeMapFileCreator> & creator)

Return value

Current

Event<const Ptr<LandscapeMapFileCreator> &> getEventProgress() const#

Event triggered on landscape map file creation progress. The signature of the callback function must be as follows:
Source code (C++)
void progress_event_handler(const Ptr<LandscapeMapFileCreator> & creator)
You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the Progress event handler
void progress_event_handler(const Ptr<LandscapeMapFileCreator> & creator)
{
	Log::message("\Handling Progress event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections progress_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
landscapemapfilecreator->getEventProgress().connect(progress_event_connections, progress_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
landscapemapfilecreator->getEventProgress().connect(progress_event_connections, [](const Ptr<LandscapeMapFileCreator> & creator) { 
		Log::message("\Handling Progress event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
progress_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection progress_event_connection;

// subscribe for the Progress event with a handler function keeping the connection
landscapemapfilecreator->getEventProgress().connect(progress_event_connection, progress_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
progress_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
progress_event_connection.setEnabled(true);

// ...

// remove subscription for the Progress event via the connection
progress_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A Progress event handler implemented as a class member
	void event_handler(const Ptr<LandscapeMapFileCreator> & creator)
	{
		Log::message("\Handling Progress event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
landscapemapfilecreator->getEventProgress().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the Progress event with a handler function
landscapemapfilecreator->getEventProgress().connect(progress_event_handler);


// remove subscription for the Progress event later by the handler function
landscapemapfilecreator->getEventProgress().disconnect(progress_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId progress_handler_id;

// subscribe for the Progress event with a lambda handler function and keeping connection ID
progress_handler_id = landscapemapfilecreator->getEventProgress().connect([](const Ptr<LandscapeMapFileCreator> & creator) { 
		Log::message("\Handling Progress event (lambda).\n");
	}
);

// remove the subscription later using the ID
landscapemapfilecreator->getEventProgress().disconnect(progress_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all Progress events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
landscapemapfilecreator->getEventProgress().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
landscapemapfilecreator->getEventProgress().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler(const Ptr<LandscapeMapFileCreator> & creator)

Return value

Current

Event<const Ptr<LandscapeMapFileCreator> &, const Ptr<LandscapeImages> &, int, int> getEventCreate() const#

Event triggered on landscape layer map file creation. The signature of the callback function must be as follows:
Source code (C++)
void create_event_handler(const Ptr<LandscapeMapFileCreator> & creator,  const Ptr<LandscapeImages> & images,  int x,  int y)
You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the Create event handler
void create_event_handler(const Ptr<LandscapeMapFileCreator> & creator,  const Ptr<LandscapeImages> & images,  int x,  int y)
{
	Log::message("\Handling Create event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections create_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
landscapemapfilecreator->getEventCreate().connect(create_event_connections, create_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
landscapemapfilecreator->getEventCreate().connect(create_event_connections, [](const Ptr<LandscapeMapFileCreator> & creator,  const Ptr<LandscapeImages> & images,  int x,  int y) { 
		Log::message("\Handling Create event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
create_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection create_event_connection;

// subscribe for the Create event with a handler function keeping the connection
landscapemapfilecreator->getEventCreate().connect(create_event_connection, create_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
create_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
create_event_connection.setEnabled(true);

// ...

// remove subscription for the Create event via the connection
create_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A Create event handler implemented as a class member
	void event_handler(const Ptr<LandscapeMapFileCreator> & creator,  const Ptr<LandscapeImages> & images,  int x,  int y)
	{
		Log::message("\Handling Create event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
landscapemapfilecreator->getEventCreate().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the Create event with a handler function
landscapemapfilecreator->getEventCreate().connect(create_event_handler);


// remove subscription for the Create event later by the handler function
landscapemapfilecreator->getEventCreate().disconnect(create_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId create_handler_id;

// subscribe for the Create event with a lambda handler function and keeping connection ID
create_handler_id = landscapemapfilecreator->getEventCreate().connect([](const Ptr<LandscapeMapFileCreator> & creator,  const Ptr<LandscapeImages> & images,  int x,  int y) { 
		Log::message("\Handling Create event (lambda).\n");
	}
);

// remove the subscription later using the ID
landscapemapfilecreator->getEventCreate().disconnect(create_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all Create events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
landscapemapfilecreator->getEventCreate().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
landscapemapfilecreator->getEventCreate().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler(const Ptr<LandscapeMapFileCreator> & creator, const Ptr<LandscapeImages> & images, int x, int y)

Return value

Current

static LandscapeMapFileCreatorPtr create ( ) #

The LandscapeMapFileCreator constructor.

void setResolution ( const Math::ivec2 & resolution ) #

Sets a new landscape map resolution.

Arguments

  • const Math::ivec2 & resolution - Two-component vector (X, Y) representing new landscape map resolution along X and Y axes to be set, in pixels.

Math::ivec2 getResolution ( ) const#

Returns the current landscape map resolution.

Return value

Two-component vector (X, Y) representing current landscape map resolution along X and Y axes, in pixels.

void setGrid ( const Math::ivec2 & grid ) #

Sets a new grid size for the landscape map.

Arguments

  • const Math::ivec2 & grid - Two-component vector (X, Y) representing number of tiles of the landscape map along X and Y axes.

Math::ivec2 getGrid ( ) const#

Returns the current grid size for the landscape map.

Return value

Two-component vector (X, Y) representing number of tiles of the landscape map along X and Y axes.

float getProgress ( ) const#

Returns the current landscape map file creation progress.

Return value

Current landscape map file creation progress (percentage).

double getTimeSeconds ( ) const#

Returns the landscape map file creation time. You can use this method to get total file generation time when processing an End callback.

Return value

Landscape map file creation time, in seconds.

void setPath ( const char * path ) #

Sets a new path to the .lmap file to be generated.

Arguments

  • const char * path - New path to the .lmap file to be generated.

const char * getPath ( ) const#

Returns a path to the .lmap file to be generated.

Return value

Path to the .lmap file to be generated.

void setDownscaleFilter ( Landscape::TYPE_FILE_DATA file_data_type, Image::FILTER filter ) #

Sets a new filtering type to be used for image downscaling performed for LODs of the specified file data type.

Arguments

Image::FILTER getDownscaleFilter ( Landscape::TYPE_FILE_DATA file_data_type ) const#

Returns the current filtering type used for image downscaling performed for LODs of the specified file data type.

Arguments

Return value

Filter type used for image downscaling. See the Unigine::Image Enumerations with FILTER_* prefixes.

bool run ( bool is_empty = false, bool is_safe = true ) #

Runs the landscape map file creation process. You can set callbacks to be fired in the beginning, upon completion and during the process to monitor progress and display statistics. Creates the landscape map file path if it doesn’t exist yet (including subdirectories).

Arguments

  • bool is_empty - true to create an empty .lmap file (e.g., when you create a layer map to be manually sculpted from scratch using brushes), false - to get necessary data from the sources and put them to the generated .lmap file.
  • bool is_safe - true to make the Engine automatically call filesClose()/fileOpen() methods when performing operations (before modifying an .lmap file the Engine should release files via filesClose(), while after modification fileOpen() should be called), false - to call filesClose()/fileOpen() methods manually.

    The Landscape class has two overloads for the filesClose() method:

    • filesClose() - to be called in case of moving an .lmap file (no data reloading is performed as the file itself was not modified - saves time on reloading data)
    • filesClose(reload_files) - to be called in case of deleting or modifying an .lmap file.
    Notice
    When is_safe = true the Engine shall always call filesClose(reload_files) with complete data reloading.

Return value

true if the operation is successful; otherwise, false.
Last update: 2023-12-19
Build: ()