AR Build in Unreal Engine 5 for IOS device and talking about Particle Spawn Groups

Setting up an Augmented Reality (AR) project in Unreal Engine on a Mac and deploying it to an iPad is an exciting process that allows you to create immersive AR experiences. 

You can refer to this video for setting up certificates and other required authorization to proceed with the project:

Here's a step-by-step guide to help you get started:

1. Install Unreal Engine: Download and install Unreal Engine on your Mac by visiting the Epic Games website (https://www.unrealengine.com/). Follow the instructions provided to set up and launch Unreal Engine on your Mac.
2. Create a New Project: Open Unreal Engine and create a new project by selecting the appropriate template. For an AR project, you can choose either the "Blank" or "First Person" template and enable AR support.
3. Enable ARKit Plugin: Unreal Engine uses Apple's ARKit framework for AR development on iOS devices. Enable the ARKit plugin by going to the "Edit" menu, selecting "Plugins," and searching for "ARKit." Enable the plugin and restart Unreal Engine for the changes to take effect.
4. Configure Project Settings: Open your project's settings by going to the "Edit" menu and selecting "Project Settings." Under the "Platforms" section, select "iOS" and configure the project's settings such as bundle identifier, version, and signing certificates.
5. Connect iPad: Connect your iPad to your Mac using a USB cable. Make sure your iPad is recognized by your Mac and appears in Xcode as a valid device.
6. Launch Xcode: From Unreal Engine, go to the "File" menu and select "Package Project > iOS." This will generate an Xcode project for your Unreal Engine project.
7. Set Deployment Target: In Xcode, select your project's target and navigate to the "General" tab. Set the deployment target to match the iOS version installed on your iPad.
8. Configure Signing: In the "Signing & Capabilities" tab of your project's target, configure the signing settings by selecting a valid development team and provisioning profile. Make sure the selected team matches the one associated with your Apple Developer account.
9. Build and Deploy: Build your project in Xcode by clicking on the "Build" button. Once the build is successful, connect your iPad to your Mac and select it as the deployment target in Xcode. Click on the "Run" button to deploy the AR project to your iPad.
10. Test and Iterate: After deployment, your AR project should launch on your iPad. Test the AR experience by interacting with virtual objects in the real world through the iPad's camera. Iterate on your project, make adjustments, and test again to refine and enhance the AR experience.

Enjoy exploring the world of augmented reality!

Developing an AR build in Unreal Engine 5 for iOS devices opens up exciting possibilities for creating immersive augmented reality experiences. Unreal Engine provides robust tools and features to create AR applications that can leverage the power of Apple's ARKit platform. One useful feature in Unreal Engine for creating visual effects in AR is Particle Spawn Groups.

Particle Spawn Groups in Unreal Engine are a powerful tool for creating dynamic and interactive particle effects. They allow you to define groups of particles with specific spawn behaviors, properties, and rules. When used in an AR context, Particle Spawn Groups can enhance the visual quality and interactivity of your AR experience.

Here's an overview of working with Particle Spawn Groups in Unreal Engine 5 for iOS AR builds:

1. Creating Particle Systems: 

Start by creating particle systems in Unreal Engine's Cascade editor. Design particle effects that fit your AR application's visual style and desired behavior. You can define particle properties such as shape, size, color, movement, and lifetime.

2. Defining Spawn Groups: 

Once you have your particle systems set up, you can create Particle Spawn Groups to manage the spawning behavior of particles. A Particle Spawn Group allows you to control when and where particles are emitted and specify rules for their behavior. For example, you can create groups that emit particles when the user interacts with virtual objects or based on specific triggers in the AR environment.

3. Setting Spawn Rules: 

In each Particle Spawn Group, you can define spawn rules to control how particles are emitted. This includes settings for the number of particles to spawn, the rate at which they spawn, their initial velocity, and their lifespan. You can also add variations to these settings to create more natural and dynamic effects.

4. Applying to AR Scene: 

To integrate Particle Spawn Groups into your AR scene, you'll need to add them to relevant AR actors or components. For example, you might attach a Particle Spawn Group to a virtual object that reacts to user input or responds to environmental cues. This allows the particle effects to be triggered and rendered appropriately within the AR environment.

5. Interactivity and User Feedback: 

Particle Spawn Groups can be used to provide interactive feedback to the user in your AR application. For example, you can create spawn rules that emit particles when the user taps on virtual objects or interacts with specific gestures. These particle effects can enhance the sense of interactivity and make the AR experience more engaging.

6. Performance Optimization: 

When working with particle effects in AR, it's essential to optimize performance for a smooth and responsive experience. Unreal Engine provides tools to optimize particle systems and Particle Spawn Groups, such as adjusting LOD (level of detail), particle culling, and system performance settings. Test your AR build on target iOS devices and iterate on the particle effects to ensure optimal performance within the AR environment.

Useful Particle Spawn Modules

Particle Spawn modules occur once for each created particle. Modules in this section set up initial values for each particle. If Use Interpolated Spawning is set, some Particle Spawn modules will be updated in the Spawn stage instead of in the Particle Update stage. Modules are executed in order from the top to the bottom of the stack.

Each of the module types in the Particle Spawn group has its own section in this document, with tables that list and describe the default options available for that type of module. Keep in mind that you can create custom modules for any part of the Niagara Emitter. The ones listed here are just the ones that are automatically included with Unreal Engine 4.

Beam Modules:

• Beam Width: This module controls the width of the spawned beam and writes that width to the Particles.RibbonWidth parameter. To vary the width along the length of the beam, use a curve indexed into the Particles.RibbonLinkOrder as provided from the default spawn beam module.
• Spawn Beam: This module places particles along a bezier spline, or simply along a line between two points. This is useful for sprite facing along a beam-style path, or for use with the ribbon renderer for a classic-style beam. Spawn Beam creates a static beam that does not recalculate the start and endpoints of each frame.

Camera Modules:

• Camera Offset: This module offsets the particle along the vector between the particle and the camera.
• Maintain Camera Particle Scale : This retains the in-camera particle size by taking into account the camera's FOV, the particle's camera-relative depth, and the render target's size.

Chaos Modules:

• Apply Chaos Data: This sets the particle position, velocity, and color from a Chaos solver.

Color Modules:

• Color: This module directly sets the Particles. Color parameter, with scale factors for the Float3 Color and Scalar Alpha components.

Event Modules:

• Generate Location Event: This generates an event that contains the position of the particle. The event payload for each particle also contains the particle velocity, a particle ID that can be used to create a Ribbon ID per particle, the age of the particle generating the event, and a random number that can be used in various ways. This module is placed after the Solve Forces and Velocity module so that the event can contain both position and velocity data.

Forces Modules:

• Acceleration Force: This adds to the Physics. Force parameter, which will translate into acceleration within the solver.
• Apply Initial Forces: This module converts rotational and linear forces, such as Curl Noise Force, into rotational and linear velocity.
• Curl Noise Force: This adds to the Physics. Force parameter using a curl noise field. Samples a medium-resolution baked tiling curl noise field by default, but can optionally sample a Perlin-derived curl function directly at an increased cost.
• Drag: This applies the Drag value directly to particle velocity and rotational velocity, irrespective of mass. It accumulates into Physics. Drag and Physics.RotationalDrag, which is solved in the Solve Forces and Velocity and Solve Rotational Forces and Velocity modules.
• Gravity Force: This applies a gravitational force (in cm/s) to Physics. Force parameter.
• Limit Force: This scales the Physics. Force parameter down to the magnitude specified if it exceeds the Force Limit.
• Line Attraction Force: This accumulates a pull toward the nearest position on a line segment. It then adds that value to Transient.PhysicsForce.
• Linear Force: This adds a force vector (in cm/s) to the Physics. Force parameter in a specific coordinate space.
• Mesh Rotation Force: This adds a rotational force as described by the newtons applied on the yaw, pitch, and roll axes, and accumulates that value to the Physics.RotationalForce parameter.
• Point Attraction Force: This accumulates a pull toward AttractorPosition into the Physics. Force parameter.
• Point Force: This adds force from an arbitrary point in space with optional falloff. Uses the vector between the velocity origin and the Particles.Position parameter in order to determine the force vector. If positions have not been initialized (that is, the particle position and velocity origin are on top of each other), the module will inject random velocity. You should place this module after any location modules in the stack, to make sure that the particle positions have already been initialized.
• Vector Noise Force: This introduces random noise into Physics. Force parameter.
• Vortex Force: This takes a velocity around a vortex axis (with an optional additional pull towards the vortex origin) and injects it into the Physics. Force parameter.
• Wind Force: This applies a wind force to particles, with an optional Air Resistance parameter. If the particle is moving faster than the wind speed in the direction of the wind, no additional force is applied.

Initialization Modules:

• Initialize Particle: This module contains several common particle parameters, which you can enable or disable as needed. There are Point Attributes such as Lifetime, Position, Mass, and Color; Sprite Attributes such as Sprite Size and Sprite Rotation; and Mesh Attributes such as Mesh Scale. This module should be at the top of the stack in the Particle Spawn group.
• Initialize Ribbon: This module contains several common parameters for ribbons. It has the same Point Attributes as the Initialize Particles module and additionally has Ribbon Attributes such as Ribbon Width and Ribbon Twist. This module should be at the top of the stack in the Particle Spawn group.

Kill Modules:

• Kill Particles: This switch kills all particles if set to True (the box is checked). It allows for particles to be dynamically killed, based on this boolean, at any point in the execution stack.
• Kill Particles in Volume: Interpolated Spawn

Location Modules:

• Box Location: This spawns particles in a rectangular box shape.
• Cone Location: This spawns particles in a cone shape.
• Cylinder Location: This spawns particles in a cylinder shape, with lathe-style controls to modify the profile of the cylinder.
• Grid Location: This spawns particles in an even distribution on a grid.
• Jitter Position: This jitters a spawned particle in a random direction, on a delay timer.
• Rotate Around Point: This module will find a position on a forward vector-aligned circle around a user-defined center point. The radius and position along the circle can be modified over time.
• Skeletal Mesh Location: This places particles on a bone, socket, triangle, or vertex of a Skeletal Mesh.
• Sphere Location: This spawns particles in a spherical shape, with options for hemisphere shaping and density.
• Static Mesh Location: This spawns particles from the surface of a static mesh.
• System Location: This spawns particles from the system's location.
• Torus Location: This spawns particles in a torus shape.

Mass Modules:

• Calculate Mass and Rotational Inertia by Volume: This parameter calculates the mass and rotational inertia based on the particle's bounds and density value. The density is measured in kilograms per cubic meter.
• Calculate Size and Rotational Inertia by Mass: Calculates the particle's scale and rotational inertia based on user-driven mass and density values. The density is measured in kilograms per cubic meter.

Materials Modules:

• Dynamic Material Parameters: These write to the Dynamic Parameter Vertex Interpolator node in the Material Editor. To use Indices 1-3, change the Parameter Index on the node itself in the Material Editor to the corresponding number. This allows the use of up to four unique dynamic parameter nodes in a given material.

Math/Blend Modules:

• Cone Mask: This module defines a cone in 3D space and checks if the position input lies inside the cone. If the position lies inside the cone, it returns 1; otherwise, it returns 0.
• Lerp Particle Attributes: This module enables linear interpolation (lerp) of all default particle parameters. You can select the specific parameter to interpolate each default particle parameter against, and also the interpolation factor for each default particle parameter.
• Recreate Camera Projection: This module recreates the camera-relative world position of a 2D scene capture's pixel. The projector transform fields allow you to reposition and rotate the projected positions.
• Temporal Lerp Float: This module performs a slow linear interpolation (lerp) according to the user's specified Current Value over time. The convergence rate is specified through the Rate of Change input.
• Temporal Lerp Vector: This module performs a slow linear interpolation (lerp) according to the user's specified Current Value over time. The convergence rate is specified through the Rate of Change input.

Mesh Modules:

Initialize Mesh Reproduction Sprite: This module first chooses a random location on a skeletal mesh. Then, using the chosen triangle, it calculates an ideal particle size, UV scale, sprite alignment, and so on. To properly align a particle to a mesh surface, set the sprite's Render Alignment to Custom Alignment, and set the Facing Mode to Custom Facing. Then set the Custom Facing Vector Mask to 1, 1, 1.

If the mesh does not animate, you can check the box for Overwrite Intrinsic Variables to set all of the particle system's intrinsic parameters. If you want the Facing Mode to update during the effect, do not check the Overwrite Intrinsic Variables box. Instead, add the Update Mesh Reproduction Sprite module to the Particle Update group. Within your material, use Niagara_MeshReproductionSpriteUVs to sample the mesh's UVs.

Both the Initialize Mesh Reproduction Sprite module and the Update Mesh Reproduction Sprite module assume that the skeletal mesh UVs are square, and not compressed on one axis.

Sample Skeletal Mesh Skeleton: This module samples the bone or socket positions of a skeletal mesh and then writes those sampled values to particle parameters. These particle parameters can then be used later in the stack.

Sample Skeletal Mesh Surface: This module samples the surface of a skeletal mesh and then writes those sampled values to particle parameters. Those particle parameters can then be used later in the stack.

Sample Static Mesh: This module samples a static mesh and then writes those sampled values to particle parameters. Those particle parameters can then be used later in the stack.

Update Mesh Reproduction Sprite: This module is used along with the Initialize Mesh Reproduction Sprite module. To recreate the effect in the Niagara level of Content Examples, follow these steps:

• Place the Initialize Mesh Reproduction Sprite module in the Particle Spawn group.
• Place the Update Mesh Reproduction Sprite module into the Particle Update group.
• In the Sprite Renderer, set Alignment to Custom Alignment; set Facing Mode to Custom Facing Vector; set Custom Facing Vector Mask to 1, 1, 1.
• In your Material, use Niagara Mesh Reproduction Sprite UVs to sample the mesh's UVs.
• If Module.OverwriteIntrinsicVariables is set to False, make sure that this module's output variables drive the particle's attributes (such as position, alignment, and so on).

Orientation Modules:

• Align Sprite to Mesh Orientation: This module aligns sprites to a mesh particle's orientation. This enables you to use the Mesh Rotation and Rotational Velocity modules to control a sprite's alignment in relation to the world. Make sure that the Alignment and Facing Mode settings in the Sprite Renderer are set to Custom Alignment and Custom Facing. Set your Custom Facing Vector Mask to 1, 1, 1.
• Initial Mesh Orientation: This module aligns a mesh to a vector or rotates it in place using a rotational vector.
• Orient Mesh to Vector: This module aligns a mesh to an input vector.

Physics Modules:

Add Rotational Velocity: This module adds to the Rotational Velocity value in a user-defined space.

Find Kinetic and Potential Energy: This module returns the following:

• A particle's kinetic energy is based on the particle's velocity.
• A particle's potential energy is the sum of all force modules that write to Physics.PotentialEnergy.
• The sum of 1 and 2.

SubUV Modules:

• SubUVAnimation: Some sprites are made in a grid, with each individual sprite representing an animation frame. This module accepts the total number of sprites that are to be animated and plots those sprites along a curve so that they animate smoothly.

Texture Modules:

• Sample Pseudo Volume Texture: This module samples the color of a pseudo volume texture, based on UVW coordinates.

Utility Modules:

• Do Once: This module keeps track of whether its trigger condition has ever been true in a previous frame. If not, Particles.Module.Execute returns True. If the trigger condition has returned True in a previous frame, Particles.Module.Execute returns False.
• Increment Over Time: This module increases the value of each frame. The counter variable increments using the tick delta value and multiplying it by a user-specified rate.
• Update MS Vertex Animation Tools Morph Targets: This module reads morph target texture data, and outputs positions and normal vectors for a given pixel-per-particle index. Pipe the module's world space normal output into the asset's material, with tangent space normals disabled within the material in order to reproduce the mesh's surface. For more information on generating morph target textures, see Vertex Animation Tool. This module can directly set a particle's position. If you use it this way, do not use another module that directly sets a particle's position.

Vector Field Modules:

• Apply Vector Field: This module takes the vector samples by a vector field sampler and applies it as a force or velocity.
• Sample Vector Field: This module samples a vector field, applying a per-particle intensity factor and an optional falloff factor, that fades the influence of the vector field towards the edges of the bounding box. This can optionally apply a local translate, rotate, or scale transformation.

Velocity Modules:

• Add Velocity: This module assigns a velocity to spawned particles. You can add various dynamic inputs to modify the values you enter in this module.
• Add Velocity from Point: This module adds velocity from an arbitrary point in space, with an optional falloff. It uses the vector between the velocity origin and the particle's position to determine the velocity vector. If particle positions have not been initialized (causing the particle position and velocity origin to be too close together), the module will inject random velocity. For the most accurate results, place this module below any location modules in the stack. This ensures that particle positions have been initialized.
• Add Velocity in Cone: This module adds velocity to the Particles. Velocity parameter in a cone shape, with parameters for cone angle, and for velocity distribution along the cone axis.
• Inherit Velocity: This module adds inherited velocity from another source. This defaults to the position of the system that owns the current emitter.
• Scale Velocity: This module multiplies Particles. Velocity by a separate vector in a specific coordinate space.
• Static Mesh Velocity: This module adds velocity based on the normals from a static mesh, as well as adding the inherited velocity of a static mesh.
• Vortex Velocity: This module calculates an angular velocity around a vortex axis and injects it into the Particles. Velocity parameter. This is added to the initial velocity the particle has when spawned.

New Scratch Pad Module:

Selecting this item in the Add (Plus sign) menu opens the Scratch Pad panel (by default this docks next to the System Overview) and places a Scratch Pad module in the Selection panel. You can also open the Scratch Pad panel by using Windows > Scratch Pad. 

 

However, by placing a Scratch Pad module in the stack, any modules or dynamic inputs you create in the Scratch Pad are automatically connected to your script. If you open the Scratch Pad panel using the Windows menu, any items you create there will have to be added to your script manually.

Alternative Approach to Emulate AR Experience: