Exploring Heart Rate Variability and Mental Effects of Gameplay in Virtual Reality and 3D Morphing Animation

Abstract

This study presents a research approach to creating 3D animations in a virtual reality game using the morphing technique as well as heart rate variability (HRV) analysis. The aim is to investigate the mental effects of the game on players by analysing electrocardiographic signals recorded before and during the game. The animations were created using Java(ver.1.8)/Java3D(ver.1.6), Blender(ver.3.1.2), and Unity(ver. 2021.3.6f1). The techniques used are Morph Interpolator in Java3D, as well as Blend Shapes and Keyframes in Blender. Animation in Unity does not have direct support for morphing, which necessitates the use of Blend Shapes and Blender. Formats such as OBJ and FBX were used to transfer data between the platforms. In addition to the software implementation of the game animation, the study offers a comparative analysis between two of the platforms (Java/Java3D and Blender) in terms of their effectiveness, advantages, and disadvantages in implementing morphing animations. The software solutions used create high-quality animations, which are necessary for generating an interactive virtual environment leading to mental stress during the game. The effectiveness of the proposed approach is proven through HRV analysis, with the results showing the psychological effect of the game on users, expressed in a decrease in HRV.

1. Introduction

One of the fastest growing industries in the modern world is 3D graphics, with virtual reality (VR) being fundamental. It is widely used in various fields, such as entertainment, medicine, architecture, etc. In these sectors, 3D animation [1,2] plays a key role, with its methods of use and goals varying depending on the specific requirements of each field.

In the industrial sector, VR can be used for simulations of work processes, personnel training, and machine design, which significantly reduces costs and the risk of errors [3,4]. In the automotive industry, VR allows for rapid testing of new models without the need for physical prototypes [5,6], while in construction and architecture, it is used to visualise projects in their real scale before they are built [7,8]. Thanks to these applications, VR contributes to more efficient, safe and innovative industrial processes.

The entertainment industry is one of the leading sectors in which 3D graphics are applied, covering films, television productions, video games, and advertising [9,10,11,12,13]. The main goal of 3D graphics is to create visually compelling content that appeals to a broad audience. In cinema, 3D animation is used in two main formats: fully animated films created entirely with 3D software, and partially animated films that combine real footage with computer-generated elements. Video games also play a key role, with 3D animation essential for realism and dynamism in virtual worlds, significantly increasing player engagement [9,10,11,14]. Video game development is closely linked to hardware and software platforms, with popular ones including Xbox, PlayStation, and mobile devices.

In medicine, 3D animation plays an important role in visualising complex biological processes and medical procedures, which aids in the education and understanding of medical conditions and therapies [9,15]. In addition, VR games can induce psychological stress, and the impact on the autonomic nervous system can be studied by analysing heart rate variability (HRV) [16,17] to determine the cardiac status of the playing individual. When extreme VR games and 3D films [18] (for example, horror) have a high level of immersion and intensity, HRV decreases [19].

The use of 3D graphics and animation in industries such as entertainment and medicine confirms the growing importance of these technologies. It opens up new opportunities for innovation in the field of VR. Creating photorealistic images and animations pushes the boundaries of imagination in cinema, video games, and architecture, providing unprecedented opportunities for experimentation and development. In video games, 3D animation is fundamental in creating dynamic and immersive virtual worlds, and 3D morphing technology can take the industry to a new level. This technology improves the realisation of movements and interactions and provides new opportunities for creating adaptive and unpredictable gaming experiences that significantly increase player engagement.

Morphing, a concept applied in 3D graphics and animation, is usually associated with transforming objects or shapes that go through different stages or states [20,21,22,23,24,25]. This can include changes in the geometry or animations of objects, such as smooth transitions between different shapes. In virtual reality and gaming, this principle finds wide application, as morphing can be used to create dynamic and adaptive objects that respond to the player’s actions. Thus, instead of objects being static and predefined, they can change their state depending on the interaction with the player, adding reactivity and realism to the gaming experience.

Although research related to morphing technology in VR games is not as widespread, some publications examine the use of dynamic and adaptive techniques in 3D graphics and VR. This research highlights the importance of such methods for creating interactive and personalised gaming experiences, which shows the potential of the morphing technique as an essential tool in this context.

Freiknecht and Effelsberg [26] consider the procedural generation of 3D content for VR games, focusing on methods that allow for dynamic environmental changes depending on the player’s actions. Technologies such as these can be used to create adaptive and variable gaming experiences, a form of morphing in game design.

Astheimer and Knöpfle [27] describe the techniques, principles, and problems for morphing 3D models in real time, which can be used in VR to achieve a smoother and more dynamic interaction between the user and the virtual environment.

The main objective of the work carried out by Lin et al. [28] is to present technologies for morphing images in two-dimensional and three-dimensional formats. The authors trace the evolution of morphing methods, starting from classical techniques and moving through modern approaches that use more complex algorithms. The study does not directly address the application of morphing to VR games. Still, it describes morphing approaches that can be adapted to different situations and have potential applications in VR game development.

Although research examines morphing techniques in 3D graphics and animation, their application to VR remains understudied. These publications focus on the real-time morphing of 3D models, procedural animations, and character adaptation and do not explicitly address using 3D morphing to create interactive game mechanics in VR environments. In particular, there is a lack of in-depth research on how this technique can contribute to immersive and dynamic experiences in VR games.

The article is a continuation of the work presented by Lebamovski and Gospodinova [29], which describes the process of creating a VR game, including 3D modelling and 3D animation, by applying interpolation techniques and the mathematical apparatus used. The game simulates extreme conditions, causing mental stress, which is analysed by studying HRV, using fractal and multifractal methods to assess the stress reactions of players.

The purpose of this article is to present the implementation of the 3D morphing technique in the animation of a VR game and to explore its possibilities for creating dynamic and interactive gaming experiences that cause higher levels of mental stress compared to the game implemented in previous work [29], which leads to a greater change in HRV. To achieve this goal, the following tasks will be solved:

• Software implementation of 3D animations in a VR game, using morphing using the following technologies: Java/Java3D, Blender, and Unity;
• Comparative analysis between the two 3D animation technologies—Java/Java3D and Blender, which directly support morphing. The comparative analysis will be made regarding the following parameters: efficiency, advantages, and disadvantages in implementing morphing animations;
• To validate the game and its additional capabilities, a comparative analysis of the generated ECG signals before and during the game is performed using two different approaches to creating animations: interpolation techniques and morphing. The analysis is implemented by evaluating parameters from detrended fluctuation analysis (DFA) and multifractal detrended fluctuation analysis (MFDFA). Based on the results obtained, it is established how different software solutions for animation affect the gaming experience. In particular, it is investigated whether the use of morphing when creating animations leads to more dynamic and interactive experiences, which provoke higher levels of mental stress and lead to greater changes in HRV.

Based on the above tasks, the following hypothesis is formulated: 3D morphing in VR game animation leads to a more dynamic and interactive gaming experience, which causes higher levels of mental stress in players compared to traditional animation techniques and accordingly leads to more significant changes in HRV.

2. Materials and Methods

2.1. 3D Morphing in Game Animations

Morphing is an essential mechanism for creating animations, which involves a smooth transition between different states of objects, both in the plane and 3D space. In many 3D graphics and animation software, such as Blender and Maya, morphing is built in as a function, and in other programs, it can be implemented through auxiliary tools. Different software tools are necessary when using specialised software, such as Blender for modelling and animation, and game platforms such as Unity for real-time implementation.

Unity is one of the most used game engines, but it does not have built-in direct support for morphing, as do Java3D and Blender. In this case, the animation is generated using a morph target in Blender. To function properly, each object must have the same number of vertices and identical topology. The base object is the basic model that will be modified and serves as the basis for the remaining key objects, known as morph targets (blend shapes). In 3D graphics, objects are most often stored as a set of triangles [21,24]. To provide the necessary variety in visual variations, it is required to construct key shapes that serve as the foundation for subsequent transformations. Objects are interpolated between the initial and final shapes, creating a smooth and natural animation. Blend shapes generate a series of intermediate shapes that create the illusion of transformation and movement. This is one of the most common methods in computer graphics.

A transformation interpolator is also required to use morphing, which defines the trajectory of the morph target. The most commonly used linear interpolator provides a smooth, rectilinear, and continuous transition between positions and rotations in the animation. It is easy to implement and works quickly. In addition, more complex interpolation techniques, such as cubic or nonlinear interpolations, can be used to provide smoother and more realistic motion.

Morphism/morphing in mathematics and computer graphics are different concepts, but they share some common characteristics, such as transformation and connection between objects.

In mathematics, morphism is used for transformations in various abstract spaces, including groups and sets. These transformations can be represented by mathematical functions that determine how objects or structures change and how they can be related to each other. For example, morphism can be used for theorem proofs that examine how one mathematical structure passes into another while preserving specific properties.

In computer graphics, morphing is usually associated with animations, which use algorithms for smooth transitions between different visual objects. This can involve transitions between different shapes or images, which are helpful in creating visual effects, animations, or interactive graphics [20,22,23,26]. One of the most common examples of morphing in graphics is when one 3D image or model transitions into another, such as from a realistic person to a cartoon character. These transitions are achieved through methods such as “interpolation pattern”, where key images or shapes are used, and the transformation path between them is calculated. The visual effects achieved through morphing can be awe-inspiring and are often used to create the impact of shrinking, deforming, or combining different objects.

Morphism in mathematics helps prove theorems, work with various mathematical models, and analyse structural changes. In computer graphics, morphing is a fundamental tool for creating photorealistic and interactive animations, which find applications in games, films, advertising, and virtual reality.

Some common principles exist despite the differences between morphism and morphing in mathematics and computer graphics. In both cases, transformations of objects or structures are considered, tracing their development over time or space. Additionally, in mathematics and computer graphics, morphism/morphing requires specialised algorithms and approaches to achieve smoothness in the transformation. In computer graphics, various techniques are used to interpolate geometric shapes, usually working with 3D coordinates that are transformed to new positions, while in mathematics, algorithms for geometric calculations or mathematical theories are applied to transform spatial structures.

In 3D modelling and animation, the term explode denotes a process in which complex objects are divided into constituent parts to visualise the individual components [30,31]. In Blender, this command ungroups objects, which is especially useful in complex scenes requiring multiple elements’ separation and dispersion.

Creating an exploded view in 3D modelling software involves separating and positioning objects. This process is usually accomplished by manual adjustment and tweaking. Exploding 3D objects is morphing and requires specialised software such as Blender combined with Unity or Java3D.

The animation formats are FBX and OBJ. The animation is stored in the FBX format when working with Blender and Unity. At the same time, Java3D, as a library/programming interface, does not support the FBX format, but uses OBJ files, which are suitable for static objects. In Java3D, the animation is realised by exporting several OBJ files from Blender, which are then imported and animated using the built-in morphing functions or by combining them with other animation techniques. The result is similar to morphing targets in Blender, but the simulation is faster and easier to program in Engine.

To reduce the load on the system, optimisation of the transfer and animation process between Blender and Unity is necessary. The main steps of this process are as follows:

• Defining the base morph target, which serves as the basis of the animation;
• Creating key shapes—usually three in number, with the same number of vertices and identical topology, ensuring a smooth transition between objects;
• Generating the animation by setting keyframes, specifying their number and duration;
• Save the animation and all objects (base and key), geometry, and visual characteristics in FBX format.

To use the animation in Unity, the FBX file must be converted so that Engine can recognise and reproduce it. For this purpose, Unity has an animation system called Mecanim, which manages the playback.

There are two options when animating a model in Blender:

• Saving the animation in one common clip;
• Splitting the animation into several smaller clips.

In the first case, the file size may become too large, leading to system load and slowdown. This can also complicate graphics management. Therefore, storing individual animations in different files is recommended, which improves performance and makes them easier to manipulate. The transition from Blender to Java3D is carried out in the following steps:

• Exporting 3D files in OBJ format using the Unity animation in Blender;
• Importing and converting the files into Java3D Node;
• Setting visualisation using material and texture;
• Connecting to a Morph Interpolator, the speed and duration of the animation are set using the Alpha class;
• Connect animation files to audio files imported into the software, setting the behaviour of objects during collision and interaction.

Different files are used to create VR applications, each performing a specific function. This ensures efficiency and optimal presentation of the animation, guaranteeing high performance and visualisation quality.

Collision detection is a key technology in 3D simulations, VR, 2D and 3D game development, and physics simulations [32,33,34]. It plays a crucial role in providing interactivity and realism in these applications. When creating VR applications, it is necessary to perform multiple interactions between different objects and between the player and the virtual environment. To achieve an exciting and immersive experience, VR uses collision detection technology, which identifies collisions between objects and can cause dynamic deformations or explosions in three-dimensional space. Collision detection techniques are often combined with morphing and interpolation algorithms, allowing smooth transitions and realistic animations of interactions between objects.

One of the primary methods for collision detection is bounding volume hierarchies (BVH), which includes geometric objects such as cubes, spheres, and others. This technique is effective in detecting collisions between objects, as it helps to reject objects that are not nearby quickly. For the user to interact with the VR game, a fast collision detection check and adequate processing of the results of these collisions are required.

The collision detection process in VR games and simulations is usually divided into two phases: a broad and a narrow phase. The first phase uses simple methods to quickly filter out objects that cannot collide with each other. The second phase applies more sophisticated algorithms, such as Gilbert–Johnson–Keerthi (GJK), to calculate collisions and determine interactions between objects accurately. Collision detection is especially important in the context of physics and computer graphics. For example, in 3D game development, collision detection can determine situations of intersection or interaction between objects in the game space. Each object must be mathematically accurately described to detect collisions. For this purpose, specialised 3D modelling software is used, which, in combination with a programming language, allows the creation of objects with precise geometric parameters.

A collision between two objects can be detected by calculating the distance between their centres. The objects are in contact or overlap if the distance is zero or negative. When working with more than two objects, checks are performed for all possible pairs of objects to detect a collision. If n objects exist, n(n − 1)/2 combinations are needed to check all potential collisions.

In Java3D game development, the bounding volume method detects collisions in 3D space. Unity uses NVIDIA’s PhysX (for example, GJK) physics engine, which relies on simple collision shapes such as spherical, cubic, capsule, and cylindrical colliders. A mesh collider can also be used for more complex cases, allowing collision detection with more complicated and detailed object shapes. These techniques allow for precise collision detection in 3D space while maintaining the efficiency and high quality of real-time animations.

2.2. Modelling and Animation

The process of creating 3D animation in VR game development involves several basic techniques: interpolation (linear, rotational, spline, Bezier, and colour) and morphing [35]. Figure 1 shows a flowchart of the main components of animation. Modelling is a key element of interactive simulation. After the 3D object is created, it is animated using interpolation and/or morphing [36]. The movement of the virtual camera in the application is controlled using curves [37]. Polygonal modelling can be used to build buildings and other objects. This approach creates three-dimensional shapes in a network of connected vertices, which most often describe triangles. The starting point for this type of modelling is usually a geometric primitive, such as a regular polygon, cube, prism, or others. Objects are built using edges and faces, and their structure determines the topology of the connecting vertices. These vertices are often extruded into space [36]. This modelling method is suitable for building complex objects and is easily combined with animation. The created models are interpolated into three-dimensional space using the above software tools. Appropriate use of textures and materials is necessary for the objects to look more realistic [36,38]. Materials determine the colouring, while textures add two-dimensional images to the three-dimensional object. Most software allows a combination of these techniques.

The main components of animation are as follows:

• Geometry—the mathematical description of the object and its structure;
• Rendering—the way the object is perceived visually;
• Keyframe characteristics—determine the movement and transformations of the object.

The formats for storing 3D models and animations are as follows:

• OBJ files: This format stores the geometry and visual characteristics of objects, including normals, textures, and materials [39]. It provides information about vertices, drawing primitives, and connection topology. It is often used in Java3D game development, where interpolators and morphing are part of the programming language documentation;
• FBX files: The FBX format stores geometry and visualisation while including information about keyframe animation created in Blender. Keyframes are the basis of animation in both 2D and 3D graphics. They are set in the appropriate modelling software, which interpolates key shapes to achieve the final result.

Unlike Java, Unity does not have a built-in direct morphing mechanism. In this case, Blender can be used to create blend shapes/morph targets that compensate for this lack.

2.3. Mathematical Apparatus for 3D Animation

When animating objects in VR games, various interpolations and transformations are used, which are necessary to implement morphing. Through transformations in space (Transform3D), basic movements can be performed, including three-dimensional modelling [30]. The mathematical apparatus is related to linear algebra, trigonometry, and curves (Spline, Bezier, and NURBS) [36,38,39,40].

The camera’s primary movement is implemented using a cubic spline curve in Java3D and a Bezier curve in Unity. In both cases, control over the speed and duration of the animation is possible. The difference is that with Transform3D, changes can be made in real time by pressing a key or a joystick button, while with movement along a curve, it is set in advance. The same techniques can be applied to other objects in the game, not just the camera.

Trigonometry and linear algebra are essential tools for animating the camera and objects. For this purpose, matrices (3 × 3 and 4 × 4) and trigonometric functions such as sine and cosine are used [41]. Combining different transformations (rotation, translation, and scaling) into a single matrix, called homogeneous coordinates, is possible. These transformations are used both in object modelling and in animations through morphing. In addition, collisions between two or more objects can be detected using geometry.

2.4. Interpolators

3D interpolation is a key technique in computer graphics that allows calculating values of a given function in three-dimensional space when only a part of the values is known. By using boundary parameters, interpolation determines the values at intermediate points to create a continuous and smooth function that describes the data in the entire range of space. The main inputs for 3D interpolation include the following:

• Determination of a finite number of vertices in 3D space (x, y, z);
• Calculation of the values of the function for the corresponding points in space;
• Calculating values for points between known vertices that will be used for interpolation.

Linear interpolation in 3D space divides it into geometric shapes, such as a pyramid (tetraeder) or a cube, and allows the calculation of intermediate values between known points [42]. This method is simple and fast but does not provide as smooth transitions as other, more complex methods.

Interpolating using curves, such as Bézier or cubic splines, achieves a smooth transition between known values. The most commonly used spline is the cubic spline, which creates smooth transitions between segments through four control points for each segment. This method is particularly suitable when smooth movement or transition between points in 3D space is necessary.

When using interpolators, the space is divided into objects or sequences of segments that are defined by curves. The choice of the appropriate interpolator depends on the needs of the application. For example, when animating complex objects, such as a camera or moving objects (car, person), curves are often combined with Transform3D for more precise movement control. The linear interpolator is suitable for morphing, where movements and deformations of objects between individual frames are interpolated. Through morphing, objects can be changed by folding or stretching, creating smooth transitions.

Interpolation is used for object movement and transitions in other parameters, such as colours and scale [40]. For example, interpolation and morphing are the primary methods for implementing smooth transitions in Java animations. In Blender, shape keys are used for the same purpose, allowing smooth transformation of objects’ geometry between different shapes.

2.5. Methods for Analysing Heart Rate Variability

Methods for analysing HRV include time, frequency, and nonlinear approaches. These approaches provide information about the adaptive capabilities of the human body in response to physical and mental stress. Changes in HRV serve as an indicator of the human body’s response to stressful stimuli, which is expressed in reduced HRV. The following two nonlinear methods were used in the present study: detrended fluctuation analysis (DFA) and multifractal detrended fluctuation analysis (MFDFA) [29,43,44,45,46].

DFA calculates long-term correlations in the signal by removing trends and analysing the dependence of fluctuations on the scale. The main parameters determined by the method are as follows: α₁ is used for small time scales (n = 4–16 intervals) and estimates short-term correlations and the dynamics of fast fluctuations in the signal; α₂ is used for large time scales (n > 16 intervals) and characterises the long-term dynamics of the signal; and α_all is calculated for the entire analysed signal and gives an average idea of the self-similarity and correlation properties of the entire signal.

MFDFA is an extension of DFA that allows analysis of multifractal properties of time series. While DFA measures the global correlation in the signal, MFDFA considers different scale dependencies and irregularities in the distribution of fluctuations. This method can be very useful for HRV analysis. The main parameters of the method are as follows: generalised Hurst exponent h(q)—estimates how fluctuations scale at different values of the parameter q; the spectrum width ∆α indicates the difference between the maximum value and the minimum value of α. A large spectrum width is an indicator of a greater non-uniformity of the signal, while a small width indicates that the signal has monofractal behaviour.

There are various tools for monitoring HRV suitable for both clinical and research purposes. These tools can be categorised into three main types:

• Electrocardiograms (ECG)—includes clinical ECG devices and portable monitors such as Holter devices.
• Chest straps with electrodes—e.g., Polar H10 and Garmin HRM-Pro, which provide data through electrical measurement.
• Optical sensors (photoplethysmography, PPG)—commonly found in smartwatches and fitness trackers.

For scientific or clinical research, ECG-based devices are the most accurate. For sports and everyday monitoring, chest straps and smart devices are the most convenient.

3. Results

Part of the implementation of the 3D morphing technique in the context of VR game animations is applied in the game “Asteroid Rain”, presented in a previous publication [29]. The game presents a scene in which asteroids fall from space to a city, and the player must destroy them to prevent them from crashing into buildings. Shooting is achieved with a weapon, while counters are used to count the elapsed time, the number of shots, and the number of asteroids hit. Audio is added for various events, such as shooting and the destruction of asteroids and buildings. Morphing in the game covers the explosions of asteroids and buildings and the movement of additional objects, such as the sea and clouds, to achieve greater realism. In Java3D, the Photontree Pro 3D helmet is used, and in the Unity environment, Microsoft HoloLens for Mixed Reality is used.

3.1. Implementation of 3D Morphing Using Java3D and Blender

Several key techniques are used together to implement morphing in the game: collision detection, explode, interpolator, and morph target. The trajectory of the game’s objects and the camera is controlled by an interpolator (linear, spline and Bezier). In this case, the camera moves along a curve (Spline in Java3D and Bezier in Unity), and the object with the morphing effect—by a linear interpolator. The interaction between the player and the VR application is carried out using a joystick and keys. In the Unity platform, morphing is implemented using FBX files that are generated in Blender. For the transition from Blender to Java/Java3D, OBJ files are used, which, after their creation, are imported into Java3D and converted into 3D objects (Java3D Node). Then, the morphing effect is implemented using the morph class by setting visual characteristics, speed, and number of animation repetitions.

The morphing process in Java3D is performed entirely through code, while Unity mainly uses commands and tools in Blender. In the latter case, the work is significantly simpler since FBX files contain all the information about the geometry of the objects, their modelling, and animation.

In Java3D, the objects in the scene are stored in a BranchGroup node (BG), as shown in Figure 2. They are divided into two types: content branch and view branch. In the case of the content branch, the BG node contains 3D information about the objects and other elements, such as audio. Transform3D determines the objects’ position, rotation, and scale and is associated with a TransformGroup (TG), which arranges them in space. One TransformGroup (TG) is used for each morphing effect in the specific game. Other elements, such as buildings, sea, and clouds, use additional TransformGroups (three TGs for these objects). In Java3D and Blender, it is possible to group objects into one, which facilitates scene management.

A visualisation and geometry must be specified for each morphed 3D object. In the case of buildings and clouds, three different geometries are used for the same object to achieve the desired visual effect when morphing.

The implementation of morphing using Blender is shown in Figure 3, which is significantly more straightforward to implement compared to Java3D, as it only requires specific settings and commands in the following steps:

• A sphere or ellipsoid is added to the scene, which is the basis for the morphing animation. It is then modified using key shapes (morph target key), which define different stages of the animation;
• Animation is performed by setting a keyframe for each key position or shape in the process;
• Saving the necessary information for the animation in a 3D file format that is compatible with the chosen development environment.

Implementing morphing in Java3D and Unity begins with using Blender to create the animation and model the objects. In Blender, the animation itself is defined and exported to an appropriate format, such as FBX or OBJ. These files are imported into the chosen VR game development environment, and in Java3D and Unity, the animation is played back differently depending on the platform. In Java3D, objects are converted to Java3D Nodes, and in Unity, they are used directly by animation controls and settings in the editor.

Figure 4 shows the process of modelling and animation a 3D object (building morphing) in Blender with Buildify. The main steps of the process are as follows:

• Installation of Buildify—an add-on for building buildings, through which the base is generated;
• In GeometryNodes/Edit mode, the base is extruded into a block with a certain number of floors. At this stage, the geometry of the object is generated;
• The visualisation of the buildings is set by applying a material and texture (Figure 4A);
• Switch to wireframe Edit mode and define the region/part of the building that the falling asteroid will destroy (Figure 4B,C);
• The “explode” setting is applied, which will separate the building particles upon collision (Figure 4D–F);
• Three blend shapes are drawn, which are a modification of the base “explode” object;
• The information is stored in FBX for Unity and OBJ for Java3D formats;
• The tests are performed via Java3D on (Figure 4G,H), checking the following:
  • The implementation of the morphing upon an asteroid hit to confirm that the objects are destroyed correctly and particles are generated (explode effect);
  • The implementation of the morphing upon an asteroid collision with the building, to confirm that the objects are destroyed correctly and particles are generated (explode effect);
  • Behaviour of the geometry and particles in 3D space when interacting with the collision forces;
  • Correctness of the animation of objects, including changes in the structure of the building and the movement of particles after the asteroid hits the building;
  • Checking the efficiency of the execution and visualisation of the destruction, making sure that the morphing works without lag or performance issues.

During the game, if the player does not hit the asteroid, it destroys the building. In this game version, the asteroid moves along a predefined trajectory and destroys the building in a particular area. Since the trajectory is fixed, complex calculations are not required for possible collisions. In future game versions, the asteroids will move along random trajectories, requiring additional calculations for all potential collisions.

In Figure 5, the process of the modelling and animation of a 3D object (dragon cloud) in Blender is shown. The main steps of the process are as follows:

• The basic shape in 3D modelling in Blender is a smoothed, subdivided primitive in the form of an ellipsoid (Figure 5A–D). This way, the polygons are divided into smaller parts to smooth the object;
• Figure 5E–G shows the modifications of the ellipsoid, which, in fact, represent a morph-target;
• Information for keyframes is shown in Figure 5H, i.e., the position of the model in time is determined, after which the modelling and animation software (Blender) interpolates the objects to obtain a smooth animation;
• Three blend shapes are drawn, which are a modification of the base object (Figure 5I–N) and are represented as dense and mesh;
• Performing a test and optimisation. If necessary and possible, the number of vertices is reduced as much as possible, thus reducing the size of the files and not loading the system when starting the game;
• For greater realism, material and texture are set for the objects to obtain a nice and finished look (Figure 5O).

Algorithm 1 shows the pseudocode for implementing morphing in Java3D. The process begins with creating a morph object that will interpolate several intermediate shapes, all with the same number of vertices and the same type of connection topology. The main steps for implementing morphing are as follows:

• Adding the necessary 3D libraries to the standard Java, including libraries such as javax.media.j3d, which will be used to create and manage 3D scenes and objects;
• Creating objects (for example, Canvas3D, which is the canvas on which the application scene will be drawn using SimpleUniverse/VirtualUniverse) depending on the need and purpose of the implementation. These classes help create virtual 3D spaces and scenes;
• Generating the necessary modifications will create the different stages of the animation; in this case, three shapes are used, representing the main key moments in the animation;
• Create an array of values—the array will contain the three intermediate shapes used for interpolation. This is the basis of the morph animation, where each shape represents the object’s state at a different moment in the animation;
• Define Alpha—this object controls the speed and duration of the animation. Alpha will be used to smoothly transition from one shape to another by interpolating the values of the vertices of the 3D objects;
• Generate an interpolator—using morphism, i.e., different values of the morph object will be defined. The interpolator will provide the smooth transformation between the intermediate shapes, a key element of the Morph;
• Add the animation to the BranchGroup (BG)—after the animation is created, it is added to the BranchGroup, which is the main element for storing 3D objects in a Java3D scene. This object will contain everything necessary for visualisation and interaction with the animation;
• Testing the animation—Once the animation has been created and added to the scene, it is ready to run and test. Testing includes checking the smoothness of the animation, the correctness of the interpolation between the shapes, and the visualisation in 3D space.

To ensure smooth and correct execution of the morphing animation, it is essential to precisely control the interpolation time via the Alpha object and to test for different parameter values such as speed and duration. Additionally, different interpolation techniques can be tested depending on the required smoothness of the animation. For example, a linear interpolator can be used for more straightforward transitions, while a spline interpolator will create more complex movements.

Algorithm 1. Pseudocode for implementing morphing in Java 3D

// Creating a 3D scene with morphing in Java3D BranchGroup group = new BranchGroup(); // Creating geometries GeometryArray shape1 = geom1.getShape().getGeometry(); GeometryArray shape2 = geom2.getShape().getGeometry(); GeometryArray shape3 = geom3.getShape().getGeometry(); //Create a massive with geometries GeometryArray[] shapes = { shape1, shape2, shape3 }; // Creating a Morph object Morph morph = new Morph(shapes); // Animation with Alpha object Alpha alpha = new Alpha(−1, 6000); // 6-s loop MorphInterpolator interpolator = new MorphInterpolator(alpha, morph); interpolator.setSchedulingBounds(new BoundingSphere()); // Adding the morph to the scene Transform3D trans = new Transform3D(); TransformGroup tg = new TransformGroup(trans); tg.addChild(morph); group.addChild(tg); group.addChild(interpolator).

3.2. Comparative Analysis of 3D Morphism Using Java/Java3D and Blender

This analysis will compare two main tools used for implementing animation for a game in VR by applying 3D morphing—Java/Java3D and Blender—and will consider the following parameters: implementation, advantages, and disadvantages.

Java3D offers limited capabilities and is not actively developed, making it difficult to develop modern VR applications. If the goal is quick and easy integration into Java-based VR environments, Java3D can be a good option. On the other hand, Blender is a potent tool for creating VR content, animations, and modelling. It is actively developed, supports new technologies, and can be easily integrated with platforms such as Unity and Unreal, which makes it suitable for professional VR games and applications.

The implementation of morphing in Java3D includes the following parameters:

• Supports OBJ files;
• Supports Morph;
• Defines key shapes;
• The morph object is controlled by weights, which change the shape of the objects and vary in the interval [0, 1];
• Animation is performed and speed is determined through an Alpha object.

The advantages of Java3D are:

• Hardware rendering is supported via OpenGL/DirectX;
• Easy control of the 3D scene;
• Easy control of the animation;
• Easy application of material and texture.

The disadvantages of Java3D are:

• Older technology and is not supported by modern VR headsets, such as Microsoft’s MR;
• Sometimes dependent on Blender;
• Does not support FBX format.

The implementation of morphing in Blender includes the following parameters:

• Shape keys are used for shapes different from the base object;
• Performs animation through keyframes.

The advantages of Blender are:

• Supports high-quality models, textures, animations, and formats, such as OBJ, FBX, ABC, etc.;
• Easily integrates with the Unity platform.

The disadvantages of Blender are:

• Other tools are required to connect to different VR environments;
• Difficult to work with.

3.3. Fractal and Multifractal Analysis

In order to analyse how the animation, realised using morphing, affects the psychological state of the players, through HRV analysis using DFA and MFDFA, the following three groups were studied:

• Group 1—RR interval series before the game;
• Group 2—RR interval series during the game, with the visualisation in the game being realised using interpolation techniques;
• Group 3—RR interval series during the game, with the visualisation in the game being realised using the morphing technique.

ECG (RR intervals) were recorded using a Dynamic ECG System TLC9803 Holter (Contec Medical Systems Co., Ltd., Qinhuangdao, China) device for 20 min on 20 volunteers, of whom 16 were men aged 27 ± 8 years and 4 were women aged 24 ± 6 years. Statistical analysis was performed with a t-test to determine the statistical significance of the studied parameters.

Table 1. HRV parameters of individuals before the game (Group 1), during the game without morphing (Group 2), and during the game with morphing (Group 3).

Parameter	Group 1 [Mean ± std]	Group 2 [Mean ± std]	Group 3 [Mean ± std]	p Value Gr1/Gr2	p Value Gr1/Gr3
Mean RR [ms]	801 ± 120	710 ± 80	660 ± 100	0.0076	0.0003
Number RR	1960 ± 250	2100 ± 150	2230 ± 270	0.03	0.0022
DFA
α1	1.167 ± 0.09	0.753 ± 0.14	0.714 ± 0.10	<0.0001	<0.0001
α2	0.945 ± 0.18	0.861 ± 0.10	0.823 ± 0.09	0.0760	0.0100
αall	0.981 ± 0.08	0.847 ± 0.02	0.811 ± 0.03	<0.0001	<0.0001
MFDFA
Hq = 2	0.979 ± 0.02	0.851 ± 0.09	0.802 ± 0.08	<0.0001	<0.0001
αmin	0.63 ± 0.06	0.79 ± 0.04	0.77 ± 0.05	<0.0001	<0.0001
αmax	1.45 ± 0.16	1.08 ± 0.11	0.98 ± 0.10	<0.0001	<0.0001
∆α = αmax − αmin	0.82 ± 0.11	0.28 ± 0.18	0.21 ± 0.09	<0.0001	<0.0001

shows the results of the analysis performed using the DFA and MFDFA methods.

4. Discussion

4.1. 3D Morphing in VR Game

Based on the techniques used in creating the game “Asteroid Rain” in virtual reality by applying morphing to animations, the following conclusions can be drawn:

• The basic concept of 3D morphing consists of transforming different shapes of the same object through a series of static images that create the illusion of movement. In Java3D, animation is controlled by a Morph Interpolator and an Alpha object, which regulate the speed and duration of transitions between shapes. In Blender, animation is implemented by keyframes, which connect the different key shapes and allow for smoother and more precise control of the animation process.
• 3D animation, especially in the context of video games, films, and virtual reality, has a limited representation in the literature, with specific implementations of morphing using Java3D and Blender being relatively rare. Blender offers a wider range of applications thanks to its support for FBX files, which include not only geometry, but also visualisation and animation. In the context of Java3D, OBJ format files contain only geometry and visualisation.
• Within Unity, although there is no built-in support for morphing, external libraries can be used to achieve this effect. However, these libraries do not provide the same degree of power and flexibility as Java3D and Blender.

4.2. HRV Analysis

The present study focuses on the relationship between the values of HRV indices before the game, on the one hand, and the stress induced by the game in VR in the players, on the other. Based on the obtained results, the following findings can be made:

• Lower values of the Mean RR parameter during the game are an indicator of a decrease in HRV, as this parameter has lower values in the game implemented with morphing. The reason for this behaviour is that under mental stress, the player’s body reacts by increasing the heart rate, which is a normal response to the stress stimulus from the game;
• Under stress, the heart rate becomes more regular, with RR intervals being less varied, leading to an increase in their number, with this value being more pronounced in the morphing game;
• Under mental stress, the values of all three parameters determined with the DFA method decrease, and this decrease is greater in the game using morphing in the animation, which confirms that it causes greater stress. Similar results have been reported in publications [16,17,44] when comparing healthy subjects with those suffering from cardiovascular diseases. The diseases also represent a source of stress for the human body;
• The value of the generalised Hurst parameter at q = 2 decreases in the ECG data recorded during gameplay. This parameter reflects the long-term correlation and fractal structure of the signal, with lower values indicating more unstable signals. In morphing games, the decrease in Hq = 2 is greater due to the increased cognitive load and stress. The morphing technique involves dynamically changing objects that create visual and cognitive discomfort, requiring the player to focus more and adapt, which leads to a higher degree of chaos in cardiac dynamics;
• The decrease in the value of the parameter ∆α, which determines the width of the multifractal spectrum during gameplay, is a sign of reduced complexity and the more uniform behaviour of the signal. During morphing, the narrowing of this parameter is greater, which is also a result of increased cognitive load and stress.
• The results of the statistical analysis of the studied parameters, obtained by t-test, show that the p-values are less than 0.05 for almost all parameters. Therefore, the used analysis methods are suitable for distinguishing the cardiological data (RR interval series) before and during the game.

Based on the results obtained from the fractal and multifractal analysis of HRV, it can be concluded that these changes are in response to the psychological load generated during the game.

These changes are more pronounced in the morphing game, which confirms the hypothesis of an increased impact on the players’ psychophysiological reactions.

This statement also applies to the influence of physiological stress as well as cardiovascular disease on HRV.

4.3. Limitations

The limitation of the present study is related to the analysis of ECG signals recorded before and during the game as follows:

• Only 20 individuals were studied, which limits the accuracy of the results obtained. A larger number of subjects would contribute to greater statistical reliability of the analysis;
• The length of the studied signals is approximately 2000 intervals, recorded over a period of 20 min. This duration was chosen due to the specificity of the study.

Despite these limitations, the results of the statistical analysis show that there is a difference between the studied groups of individuals.

5. Conclusions

Animation plays a key role in modern VR games, enhancing realism and user immersion. In the developed VR game, animation is primarily implemented through morphing, ensuring smooth transitions and natural object movement. The study explores animation mechanisms in Java3D, Blender, and Unity, highlighting their strengths and limitations. While Java3D and Blender are suitable for basic Java-based animations, Unity offers advanced capabilities for complex VR applications. Combining Blender for morphing and integrating it into Java3D and Unity enables high-quality animations and improved interactivity.

The HRV analysis before and during the game showed reduced values of the DFA-determined α1, α2, and αall parameters, as well as the generalised Hurst parameter (MFDFA) during the game. These changes can be interpreted as a response to the stress induced by the game, with the effect being more pronounced in the game with morphing animation, leading to a more significant decrease in HRV.

The innovation of this work lies in the use of morphing animation in the VR game to improve immersion, with HRV analysis confirming its psychological impact on players.

The findings of this study can be applied in therapeutic VR applications, as morphing animation can enhance immersion, making therapy more effective. In education and training simulations, smoother and more natural animations can improve user engagement and retention of information. Furthermore, HRV analysis can be used to assess a player’s stress levels in real time, allowing for adaptive difficulty settings in games or personalised VR experiences. Future research could explore how morphing techniques affect cognitive load and emotional responses in different VR environments.