We present a new scale-free geometric modelling environment designed by the author of the paper. It allows one to consistently treat geometric objects of arbitrary size and offers extensive analytic and computational support for visualization of both real and artificial sceneries.
Geometric modelling of real-world and imaginary objects is an important task that
is ubiquitous in modern computer science. Today, geometric modelling environments
(GME) are widely used in cartography [
Creating a detailed model of a real-world or imaginary environment is a task of
great computational complexity. Modelling various physical phenomena like gravity,
atmospheric light scattering, terrain weathering, and erosion processes requires full
use of modern computer algebra algorithms as well as their efficient implementation.
Finding exact and numeric solutions to differential, difference, and algebraic
equations by means of computer algebra methods (see [
There exist a wide variety of geometric modelling environments, both universal and highly specialized. They include three-dimensional planetariums like SpaceEngine or Celestia, virtual Earth engine Outerra, procedural scenery generator Terragen, 3D computer graphics editors Autodesk 3ds Max, Blender, Houdini, and 3D game engines like Unreal Engine 4, CryEngine 3, and Unity.
The present paper describes a new geometric modelling environment, SN-Engine, designed and implemented by the author of the paper. The main advantage of this GME is its capacity to consistently and in a computationally efficient way treat geometric objects of arbitrary size, from extragalactic and down to the microscopic scale.
This geometric modelling environment is a freeware implemented in C# programming language. Scripts, sample video files and high resolution images created with SN-Engine are publicly available at snengine.tumblr.com. 2
The geometric modelling environment presented in the paper shares many properties and functions with other GMEs. These include procedural generation, instruments and algorithms of 3D rendering, internal elements of system architecture, file and inmemory data formats, etc. In the Tables 1, 2, 3 we compare SN-Engine with other existing systems.
Despite the extensive capabilities of modern geometric modelling systems all of them have limitations in terms of world structure, engine modification, userworld interaction, and licensing. The presented modelling system SN-Engine is a freeware which, unlike any other software listed above, is endowed with tools for procedural generation of objects of arbitrary scale. SN-Engine no public release yet 3D computer graphics, mixed 3D computer graphics, mixed computer-aided design and drafting 3D animation, mixed urban environments generation procedural landscape generation and visualization scripted scripted partial, scripted integrated, scripted integrated integrated procedural world creation
integrated, scripted
The presented geometric modelling system unifies procedural approach to content generation and game engine technologies to create a fully flexible multiclient, arbitrary scale world creation and experience platform. The system can be used for solving various tasks like demonstration, design, recreation, and education. Its functions include generation of new content, transformation of existing content, and visualization. By organizational structure the presented geometric modelling system can be used in autonomous, local-networked or global-networked mode.
The engine provides flexibility in terms of world and entity modification, creation
and generation. The list of main features is as follows:
– Support of arbitrary scale worlds, from super galactic to microscopic level;
– Client-server world and logic synchronization;
– Scriptable game logic;
– Procedural generation [
– External data import: e.g. height maps [
The base engine realization contains a procedurally generated universe with standard node hierarchy (Fig. 1) ranging from galaxies to planet surfaces and their objects. Hierarchy is displayed in columns from left to right and from top to bottom: galaxies (a), spiral galaxy stars and dust (b), a star system, planets and their orbits (enabled for clarity) (c), an earth-like planet (d), planet surface seen from a low orbit (e), planet surface from ground level (f). In addition, other nodal hierarchies can be created with custom nodes by means of procedural generation algorithms.
A planet has a touchable surface endowed with physical properties which satisfy the laws of the physics of solids. Players can walk on a planet’s surface and interact with other objects.
(a) A spiral supergalactic system (b) A single galactic (c) A planetary system (d) An earth-like planet from the orbit (e) A planet seen from the stratosphere (f) The terrain of a planet
Fig. 1. The default world hierarchy in SN-Engine environment
The engine is implemented in C# on .NET Framework and uses Lua [
– Object system or global object management system, base for Assets, Nodes, Components, Events, and others; – Event system that manages subscription and invocation of functions; – Physics system handles physical interactions of nodes with instances of physics entities; – Sound system supports playback of sound effects and ambience in 3D space; – Horizon system providing frame of reference update and loading of nodes; – Input system or user input engine interface; – Net system that enables client-server event relay; – Rendering system which does visualization of nodes with attached cDrawable component;
– Scripting system providing safe and real-time game logic programming in Lua. The list of modules comprises the following: – Profile which stores user data, settings, saves, etc.; – Add-on or user data package manager; – GUI that renders user interface objects and their rendering; – ModelBuilder providing classes and functions for dynamic model construction; – ProcGen or operation based procedural generation system; – sGenerator or script based procedural generation system; – Flow, the node based visual programming language; – Forms, the dynamic index database of user defined data assets; – VR, the virtual reality Oculus HMD interface; – Web module that provides Awesomium browser interface, rendering to texture and control functions.
Data modules include primary asset modules which contain methods for asset
manipulation in JSON format [
The core component of the engine world structure is a node. Every node follows the set of rules: – A node can have space bounds with box, sphere or compound shape; – A node can contain any finite number of other nodes and one parent node, forming a tree graph structure;
– A node has absolute size variable measured in meters per node unit, so in case of node with spherical bounds its radius is equal to the absolute size of the node; – A node has position, rotation and scale variables which define its location and scale in its parent node; – A node has seed variable used for procedural generation; – Nodes can have components, custom variables and event listeners; – A node without parent node is the world node.
A possible node type hierarchy of a client camera flying two meters above the planet surface is as follows: 0) world sol; 1) spacecluster; 2) galaxy; 3) starsystem; 4) star; 5) planet; 6) planet surface; 7) planet surface node; 8) camera. All types in this hierarchy, with the exception for the camera type, are defined in script files.
The location variables and node hierarchy allows one to build relative transformation matrices and their inverse matrices for each parent node in its hierarchy. This in turn allows one to obtain relative transformations for any node within the same world.
The precision of 32 bit floating point numbers which are widely used in computer graphics is limited while the corresponding precision distribution is not linear. Any number with 7 or more significant decimal digits is subject to data loss during mathematical operations. There are several workaround methods to overcome this limitation and each method needs to calculate object positions in relation to camera at runtime. These methods include the following:
– Storing object positions as 64bit floats, which raises overall precision to 15 decimal digits but still has the same precision distribution limitations;
– Storing object positions as 32bit or 64bit integers, since integers have linear precision distribution;
– Storing object positions in relation to specialized group object. This method is used in most geometric modelling systems;
– Storing relative local object positions with respect to their parent object. This method requires hierarchical organization of objects.
We use the last method to solve this problem. This is done in three steps. The first two steps are performed when creating or updating a node while the third is performed at the rendering stage.
The first step is to compute the node world matrix, which consists of the node scale, rotation and position: that is, W = scale (S) · rotation (R) · translation(P). Here W is the node world matrix, is the node scaling vector, is the node rotation quaternion, and is the node position vector. The second step is to compute hierarchical matrices using world matrices obtained at the previous step and parent nodes: Here – is the identity matrix of size 4; – i is the node level in parent hierarchy, where 0 = node, 1 = parent, 2 = parent of parent, ... , n = world node; – is the i-th level node world transformation matrix; – is the i-th level parent node absolute node size in meters; – is the i-th level parent node world matrix.
Finally, the third step is the local world matrix computation (Fig. 2, where (a) is the current node, (b) is the target node, (c) is local world matrix and (d) is the closest common ancestor for the current and the target nodes). This matrix is computed as follows: Here LW is the local world matrix of node N at node C, T (the top node) is the nearest node in hierarchy to both current and target nodes, C is the current node, N is the target node, level is the node hierarchy level starting from the world node. 3.2
The engine nodes use partial implementation of Entity component system [
Core engine components (sComponent) include the following: Drawable object components (cDrawable): cModel for model instances, cParticleSystem for particle system instances, cSkybox for skybox instances, cSurface for planet surface (terrain and water) instances, cSpriteText for text sprites in 3D space, cAtmosphere for atmospheric fog, cVolume for volumetric texture renderer instances.
Update phase components (cUpdater): cOrbit which sets node position using orbital parameters and current time, cConstantRotation that sets node rotation from current time.
Physics components (include interfaces for physics engine [
Content generation components: cRenderer components that perform render to
texture operations, cCamera which renders from camera node, cCubemap that renders
6sided cubemap texture, cHeightmap draws to planetary height map texture, cInterface
renders hierarchy of panel objects to GUI texture, cShadow draws scene to cascading
shadow map [
Other component types: cLightSource point light which is used for illumination, cNavigation which generates and contains navigational map for AI actors, cPartition is hierarchical space partitioning (part of HorisonSystem), cPartition2D or quad tree partitioning (4 subspaces on 2 axes), cPartition3D or octree partitioning (8 subspaces on 3 axes), cSurfaceMod is surface data (height, temperature, etc.) modifier (cSurface), cWebInterface is web interface data container.
Here G is the gravitational constant, a is the semi-major axis, is the orbiting node mass, is the parent node mass. Subsequently in the update event we use Algorithm 1 to calculate the vector position along the shifted ellipse and then rotates it around 0 with the argument of periapsis along the Y axis, inclination along the X axis and ascending longitude along the Y axis.
Algorithm 1 orbital position update step function
return end function function GetCorrectedT(
) while
do end while return E end function Here a is the semi-major axis, b is the semi-minor axis, e is the eccentricity, p is the argument of periapsis, i is the inclination, l is the ascending longitude, t is time, is the orbital position. The value = 0.001 in parent node units is used as a precision limiter. 3.3
The horizon system provides dynamic recalculation of coordinate systems, space to space node transfer and the space partition update. The system checks all nodes with enabled space transfer flag against the bounds of their parent node and every other node in it. When a node is outside of its parent bounds or inside of any other node bounds, the system recalculates its position, rotation, velocity, and angular velocity and then changes its parent node.
The partition component generates dynamic tree structure from partition nodes and calls events to its host node. This allows one to create procedural generators for threedimensional (Octree) objects like galaxy generation, galactic cluster generation and two-dimensional (Quad tree) objects like planet surfaces. It can also be used for any other type of generation with scripting. 3.4
Procedural generation is the crucial part of the engine. It allows real-time content generation from pre-defined patterns and scripts. There are different methods of procedural content generation that are implemented in the engine including: – Node generation with scripted procedural generators in Lua or C# , e.g. cluster and galaxy generation (C#), star system generation (Lua);
– Model and node generation with operation based generation system, e.g. models
of objects, buildings; generated building interior world nodes and others;
– Texture generation from Lua scripts or JSON files;
– Texture generation from cCamera and cCubemap node components;
– Surface data generation [
Operation Based Procedural Generation System.
This system allows one to define dynamic model structures and to build complex 3D models with several levels. Models are defined in JSON-like files or Lua structures by lists of consecutive operations. These operations use named groups of 3D primitives along with parameters as input data. Fig. 3 illustrates the use of procedural generation in building interiors.
The primitive types comprise the following: point as a basic structure which contains position in the local space, path as a set of points with a loop flag, and surface or polygon which contains edge (path) and other surface properties such as material and uv-matrix.
Fig. 3. Procedurally generated interiors
The procedural generation system includes a total of 56 different operation types. The operation types are divided into groups as follows: ”Create” operations which create sets of primitives from data, ”Extend” operations which create new primitives from existing, ”Modify” operations that alter existing primitives, ”Select” operations which filter existing primitives or return their data, and ”Utility” operations which provide branching in generation algorithm.
An example of the use of operation is given by { type : ”inset”, from:”bt base”, out : [”bt base”, ”bt sides”], extrude : 0.4, amount: 0.5 }. It applies ”inset” operation (insets a polygon edge by the ”amount” value and shifts it by the ”extrude” value) for each primitive in the group ”bt base”. It outputs the central polygon to the ”bt base” group and the edge polygons to the ”bt sides” group. 3.5
Rendering system uses SharpDX [
The system uses a combination of forward and deferred rendering techniques [
Algorithm 2 Atmosphere glow and fog shader function // 1. The horizon line and gradient density calculation
// 2. Atmosphere density from view distance calculation
// 3. Light colour and sun glare calculation for do end for // 4. Atmosphere parts colour calculation // 5. Atmosphere parts density calculation // 6. Final atmosphere colour calculation return end function Here is the atmosphere colour, is the i-th star colour, is the star colour, is the star direction, M is the node scale, N is the surface normal, is the ith star direction, is the direction to the planet centre, H is the camera distance to the planet surface towards the centre of the planet, is the distance to the horizon, is the distance to the planet centre, is the depth of the current pixel, is the atmosphere width, n is the star count, is the pixel colour, lerp(a, b, d) is the linear interpolation of two vectors a and b based on the weight d.
The resulting image is blended with the current view. The numerical coefficients in the above formulas have been selected on the basis of visual perception.
Script system uses Lua [
The engine network system is based on client-server model and uses packets to transfer data. The packets are being sent and received asynchronously and incoming packets placed into a queue which is then processed from the main thread in both server and clients. 4
There exist certain limitations for each of the main systems of SN-Engine. They are summarized in the Table 4.
Hardware requirements: Processor: Dual Core CPU @ 3.0 GHz, Memory: 4GB RAM, Hard Drive: 2 GB, Graphics: Nvidia GeForce GTX 1070, 2048MB. Software requirements: OS: Windows 7, 8, 10, .NET Framework 4.0.
System Hierarchical nodal system
based procedural generation system Rendering
system
system
Limitations maximum node nesting level maximum loaded node count maximum absolute node size maximum simultaneous nodes in node polygon count complex topology maximum visible objects maximum drawable objects maximum concurrent threads maximum tasks in
thread queue maximum concurrent updatable objects maximum active objects in simulation island maximum static collision triangles per physics space maximum client connections maximum active networked nodes maximum add-on count maximum file count maximum loaded assets processing speed(from
C#) single threaded.
tens of millions
N/A thousands/ millions instances tens of thousands
fast physics: 100 slow-motion physics: thousands millions
tens hundreds hundreds tens of thousands varies from asset filesize 10000 − 100 Divided by 10-1000 N/A
memory memory double type precision memory, CPU, HDD/SSD read speed CPU, int32 maximum value procedural operations functionality GPU memory, GPU processing power
CPU, memory
CPU CPU
CPU memory, CPU CPU, network bandwidth, memory network bandwidth memory, HDD/SSD read speed memory memory
CPU CPU
The new geometric modelling system SN-Engine combines procedural generation algorithms, arbitrary scale nodal system, and extensive Lua scripting system to construct and visualize complex sceneries.
High resolution screenshots and video are available on the system website at http://snengine.tumblr.com/
This research was performed in the framework of the state task in the field of scientific activity of the Ministry of Science and Higher Education of the Russian Federation, project ”Development of the methodology and a software platform for the construction of digital twins, intellectual analysis and forecast of complex economic systems”, grant no. FSSW-2020-0008.