Overview & Setup

AsgineVFX is a GPU-driven Unity Editor authoring tool with a matching runtime for Unity 6.x on the Universal Render Pipeline. It provides a full-featured particle emitter, Bézier beams, attachment trails, gameplay modules (lightning, craters and camera shake), exchange tools and a pooled tween engine. Particles are simulated on the GPU, ribbons are GPU-rendered, and every effect shares one bloom/glow pass.

Requirements

Unity 6.xURP activeNew Input System (demo only)

Install

1. Import the AsgineVFX package (drag the .unitypackage into your Project window).
2. Select your URP Renderer asset → Add Renderer Feature → AS Particle Render Feature. This one feature draws all emitters, beams and trails and applies the shared glow.
3. Add components from the clean Add Component ▸ AsgineVFX submenu.

Namespaces

Feature Overview

The main systems included in AsgineVFX and the functionality provided by each one.

GPU Particle System

• GPU-simulated particle emitters with continuous emission and one-shot bursts.
• Box, sphere, cylinder and disc emission shapes with volume/surface and directional controls.
• Per-segment lifetime curves for color, size, independent X/Y squash, transparency and brightness.
• Flipbook animation or direct atlas-frame selection, custom materials, fixed, crossed, camera-facing and velocity-aligned particles.
• Acceleration sequences per axis, per-particle random drag/size, random loop rate, inherited velocity, global wind and moving-frame simulation.
• Particle zones for accelerated aging, entry blocking, spawn suppression and collider-driven VFX triggers.
• Prefab-style emitter variants with explicit per-property overrides and live inheritance from a base emitter.
• Multi-emitter particle sequences with scale and time-scale controls.

GPU Beam System

• Cubic Bézier ribbons between two transforms.
• Configurable widths, curve strength, segmentation, gradients and transparency.
• Camera-facing rendering, scrolling/stretching textures and shared glow.

Attachment Trails

• Continuous ribbons generated from two moving attachment transforms.
• Lifetime, minimum sample distance, optional maximum length and width-over-life controls.
• Camera-facing or attachment-plane rendering with continuous Stretch, Wrap and Static UV modes.

Gameplay VFX Modules

• Pooled procedural lightning with animation, pulse, fade and optional attached sparks.
• Rock/crater generation for impact and ground-break effects.
• Additive camera shake with reusable presets.
• A pooled typed tween engine for gameplay and VFX animation.

Authoring and Exchange Tools

• Dedicated inspectors and curve editors for particle and beam data.
• Automatic .asg import with embedded hierarchy, materials and textures.
• Assets ▸ AsgineVFX ▸ Convert Prefab to .asg for an in-project conversion.
• Assets ▸ AsgineVFX ▸ Export as .asg for sharing an effect as a standalone file.

Particle Emitter

ASParticleSystem.ASParticleEmitter — a full GPU particle emitter. Add it to a GameObject; its transform position/rotation/scale define the emission shape and orientation.

Emitting from code

using ASParticleSystem;

ASParticleEmitter emitter = GetComponent<ASParticleEmitter>();

// Continuous emission is driven by Rate while Enabled is true.
emitter.Enabled = true;

// One-shot burst using the emitter's own EmitCount:
emitter.TriggerEmit();

// Burst with a size scale and a re-timescale (0.5 = whole effect at half speed):
emitter.TriggerEmit(scale: 1.5f, reTimeScale: 0.5f);

// Burst overriding the particle count for this shot only:
emitter.TriggerEmit(countOverride: 64, scale: 1f, reTimeScale: 1f);

// Immediate raw burst / clear all live particles:
emitter.Emit(16);
emitter.Clear();

Appearance (runtime properties)

Emission & motion

Particle execution

Enable Particle Execution to fire one event per particle at the end of its lifetime, at an absolute number of seconds, or at a lifetime percentage. It can trigger a following emitter/sequence and notify components implementing IASParticleExecutionReceiver. Follow-up Spawn can start the next effect at the exact particle position or retain the target transform, then apply a position offset in world, source-emitter or target-transform space. Simultaneous executions keep independent spawn positions, and sequences preserve the layout of their child emitters. Empty receiver slots are safely ignored and remain available while the Inspector is being configured. Very short direct self-loops and excessive same-frame chains are blocked before they can freeze the client. At most 1024 execution events are transferred and dispatched per emitter and frame, independent of Max Particles, so unusually large particle capacities cannot create an unbounded GPU readback. Custom receivers receive the exact event position through ASParticleExecutionContext.Position.

Flipbook & explicit emission

Flipbook: FlipbookLayout, FlipbookMode (Loop/OneShot/PingPong/Random/FixedFrame), FlipbookFramerate, FlipbookBlendFrames, FlipbookSizeX/Y, FlipbookStartRandom. FixedFrame exposes a zero-based X/Y atlas coordinate (X right, Y down from the top row) and uses that cell without animation.
Manual shot scheduling: EmitOnAlive, EmitCount, EmitDelay, EmitDuration, TimeScaleStart/End/Duration. TriggerEmit() always starts one independent shot; emitter looping belongs to Enabled + Rate under Emission.

Diagnostics (read-only)

LiveParticleCount, LastEmitCount. Enable ShowDiagnostics for live counts. The selected emitter is visualized automatically; ShowEmitterBounds keeps the spawn shape visible while it is not selected. The old ShowEmissionBounds API remains as a compatibility alias.

Particle Emitter Variants

Build a family of related effects from one base emitter without duplicating every setting.

1. Select an emitter and press Create Variant in its Inspector, or use GameObject ▸ AsgineVFX ▸ Particle Emitter Variant.
2. Edit any field normally. The changed top-level property becomes an explicit override while every other property continues to follow the base emitter.
3. Right-click a standard property to explicitly add or revert its variant override. This also lets a value remain overridden when it happens to equal the current base value.
4. Use Manage Overrides for a searchable, sectioned view of every property, including custom controls that do not expose Unity's standard property context menu. The compact Overrides list can revert individual entries or all entries at once.

Base changes propagate to loaded variants automatically and are resolved again on validation and runtime initialization. Variant chains are supported; self-references and circular chains are rejected. Editor-only visualization preferences are local to each object and are not inherited.

Sequences & Ranges

Reusable data types shared by emitters and beams.

ASNumberSequence

Each keypoint controls the segment leading to the next point with Linear, Ease In, Ease Out, Smooth or Step interpolation. Drag a cyan segment handle to shape the curve visually. Ctrl/Cmd-click toggles keypoints, Shift-click selects a range, and dragging then moves every selected point together. Value, Random Range, curve presets and curve bend also edit the complete selection while preserving relative offsets. Press Delete/Backspace to remove selected interior points. Right-click either the compact preview or the full graph to copy and paste complete curves. Random Range adds deterministic per-particle variation around the key value.

using ASParticleSystem;

// Constant value, or edit keypoints for a curve over t = 0..1
emitter.Size.Keypoints.Clear();
emitter.Size.Keypoints.Add(new ASNumberSequenceKeypoint(0f, 0.2f, 0f)); // time, value, envelope
emitter.Size.Keypoints.Add(new ASNumberSequenceKeypoint(1f, 1.5f, 0f));
emitter.Size.Scale = 2f; // multiplies the whole curve

float v = emitter.Size.Evaluate(0.5f);

ASColorSequence

emitter.Color.Keypoints.Clear();
emitter.Color.Keypoints.Add(new ASColorSequenceKeypoint(0f, Color.red));
emitter.Color.Keypoints.Add(new ASColorSequenceKeypoint(1f, Color.yellow));

ASNumberRange

Range fields use one compact Inspector row with named From and To endpoints. Equal values represent a constant; different values sample randomly between both endpoints. Drag an endpoint label to adjust it. Hold Alt to move the complete interval, Shift to resize symmetrically around its original center, or Ctrl/Cmd to snap. Modifier changes during a drag always resolve from the original drag state.

emitter.Lifetime = new ASNumberRange(2f, 4f); // random min..max
emitter.Speed    = new ASNumberRange(5f);      // constant
float lo = emitter.Lifetime.Min, hi = emitter.Lifetime.Max;

Particle Sequence

ASParticleSystem.ASParticleSequence — groups several emitters and triggers them together as one effect — fire a whole multi-emitter VFX from a single call.

using ASParticleSystem;

ASParticleSequence seq = GetComponent<ASParticleSequence>();

seq.Play();                       // fires all assigned emitters
seq.Play(scale: 1.2f, timeScale: 0.5f); // scaled + slowed
seq.Clear();

Inspector fields: playOnAlive, reScale, reTimeScale (defaults applied by Play()), and the emitters list.

Particle Zones

ASParticleSystem.ASParticleZone — a world-space volume that affects any particle passing through it. Add the component, set its absolute world-space Size, then pick a shape and a mode. Transform position and rotation place the zone; Transform Scale is intentionally ignored so nested or scaled hierarchies do not distort its dimensions.

Particle-affecting zones are picked up automatically by active emitters. Edit Bounds provides the same six face handles as emitter shapes: normal drag moves one face, Alt resizes symmetrically, Shift preserves box proportions and Ctrl snaps. Sphere size is presented as one unambiguous world-space diameter. Matching 3D and 2D trigger colliders can be created from the Inspector and stay synchronized with Size and Center edits.

Particle Materials & Custom Shaders

The emitter's CustomMaterial accepts both native AsgineVFX particle materials and ordinary URP materials, including URP Shader Graph materials. MaterialRenderMode.Auto selects the correct renderer from the material contract.

Automatic render paths

• Procedural path: versioned AsgineVFX particle shaders use the original direct GPU-buffer renderer. This is the fastest path and supports the full particle interface, including interpolated flipbook frames.
• Mesh compatibility path: regular URP and Shader Graph materials receive a GPU-generated mesh with world position, normal, tangent, UV0 and vertex color. No particle data is copied back to the CPU.

No setup or conversion is required in Auto mode. Invalid shaders fail safely, and the inspector only reports configurations that can produce an incorrect result.

Included materials

• AsgineVFX/Particles/Unlit — tint, emission and alpha cutoff.
• AsgineVFX/Particles/Lit — URP main-light, shadows, normal map, metallic and smoothness controls.
• AsgineVFX/Particles/Anime — cel bands, silhouette outline and alpha-aware rim light.
• AsgineVFX/Particles/Dissolve — animated noise dissolve with emissive edge.
• AsgineVFX/Particles/Distortion — animated UV/heat distortion of the particle texture.

Create them from Assets ▸ Create ▸ AsgineVFX ▸ Particle Material. These materials automatically use the procedural path.

The emitter's Texture overrides the material's Particle Texture. If the emitter field is empty, the material texture is used automatically.

Alpha Source

Particle textures do not all store transparency the same way. Texture Alpha is the default and correct choice for PNG/TGA sprites with a real alpha channel. Fully opaque imported textures that encode coverage in RGB are normalized automatically, so custom Shader Graphs can use the ordinary texture Alpha output. Luminance and Alpha × Luminance remain optional artistic modes for native AsgineVFX materials.

Converting URP materials

Conversion is optional. Use it only when the material does not need its original graph or shader logic and the lower-overhead procedural path is preferred. Set Material Render Mode to Procedural, then use Convert to AsgineVFX Particle Material. The converter preserves the original and copies common surface values into a separate material.

Creating an editable particle shader

Use Assets ▸ Create ▸ AsgineVFX ▸ Shader ▸ Particle Unlit or Particle Lit to create a normal editable ShaderLab/HLSL file in the selected project folder. Both starters already contain the required AsgineVFX particle interface, transparent URP render state, flipbook sampling, emitter color, brightness and transparency handling.

Particle Unlit is a clean base for custom fragment effects and emission. Particle Lit adds main-light shadows, ambient lighting, normal-map sampling, metallic, smoothness and emission. The generated file can be edited directly without modifying package shaders or copying setup code from the documentation.

Creating an editable particle Shader Graph

Use Assets ▸ Create ▸ AsgineVFX ▸ Shader Graph ▸ Particle Unlit or Particle Lit. The new graph is an ordinary editable URP Shader Graph with transparent particle render settings, texture sampling, UV0 and emitter color/transparency already connected. Open it and build effects exactly as you would in a regular Shader Graph.

Particle Unlit is the best starting point for glow, dissolve, distortion and stylized VFX. Particle Lit additionally exposes the standard Lit inputs for normal, metallic, smoothness, emission and ambient occlusion.

Shader Graph and VFX Graph

Assign a URP Shader Graph material directly and leave Material Render Mode on Auto. Use a Transparent surface (or intentional Alpha Clipping), sample the particle texture with UV0, and multiply the graph's color and alpha by the standard Vertex Color node when the emitter's Color, Brightness and Transparency sequences should affect the result.

Auto supplies a rounded billboard normal field to regular Lit and Fresnel materials, so surface-lighting tutorials behave naturally on particles without AsgineVFX-specific graph nodes. Set Material Surface to Flat only for shaders intentionally designed for a planar card. This is a lighting representation, not real 3D geometry; effects that depend on true volume, back faces or mesh depth require a mesh rather than a billboard.

The emitter texture automatically binds to the standard _BaseMap/_MainTex references. A graph using a differently named texture property keeps the texture assigned in its material. The compatibility path selects the nearest flipbook frame when frame blending is enabled; native AsgineVFX shaders retain true two-frame interpolation.

Included Shader Graph nodes

The package includes optional Unity Sub Graphs under Assets/AsgineVFX/ShaderGraph/SubGraphs. They use public Shader Graph assets rather than version-sensitive editor extensions.

• Asgine Particle Input: connect a Texture2D property whose reference is _MainTex or _BaseMap. The node samples UV0 and returns Final RGBA, Final RGB and Final Alpha with the emitter's Color, Brightness and Transparency already applied. Texture RGBA and Particle RGBA are also exposed separately for custom effects.
• Asgine Apply Particle Color: accepts an RGBA value sampled or generated elsewhere in the graph and applies the emitter's particle color and alpha. Use this after distortion, dissolve or custom UV logic.

Find both nodes through Create Node ▸ AsgineVFX ▸ Particles. They are conveniences only; graphs using standard UV0 and Vertex Color nodes remain fully supported.

VFX Graph is a separate particle simulation system rather than a material, so a VFX Graph asset cannot be placed in CustomMaterial. Shader Graph materials are supported.

Beam

ASBeamSystem.ASBeam — a GPU ribbon between two attachment transforms, following a cubic Bézier curve.

using ASBeamSystem;

ASBeam beam = GetComponent<ASBeam>();
beam.Attachment0 = startTransform;
beam.Attachment1 = endTransform;
beam.Width0 = 1f; beam.Width1 = 3f;
beam.CurveSize0 = 4f;               // bulge along Attachment0's local +X
beam.FaceCamera = true;
beam.TextureSpeed = new Vector2(1f, 0f); // scroll: x=length, y=width
beam.SetTextureOffset(new Vector2(0.5f, 0f));

Trail

ASTrailSystem.ASTrail — a persistent ribbon between two moving attachment transforms. The attachment distance defines the base width while the stored path defines the trail shape.

using ASTrailSystem;

ASTrail trail = GetComponent<ASTrail>();
trail.Attachment0 = leftEdge;
trail.Attachment1 = rightEdge;
trail.Lifetime = 0.8f;
trail.MinLength = 0.05f;
trail.MaxLength = 12f;
trail.FaceCamera = false;

// Immediately discard the recorded path.
trail.Clear();

Lightning

Game.Lightning.ASLightningManager — a pooled, self-ticking lightning system. Access it through its lazy singleton.

using Game.Lightning;

ASLightningBolt bolt = ASLightningManager.Instance.Spawn(from, to, partCount: 30);
bolt.MinRadius = 1f;
bolt.MaxRadius = 2.5f;
bolt.Thickness = 1.1f;
bolt.PulseSpeed = 10f;
bolt.FadeLength = 0.4f;
bolt.Color = solidGradient;      // UnityEngine.Gradient

// Attach continuously-emitting sparks to a bolt:
ASLightningManager.Instance.AttachSparks(bolt, maxSparkCount: 6);

bolt.Restart();  bolt.Kill();

Bolt tuning fields include MinRadius/MaxRadius, Thickness, Frequency, AnimationSpeed, PulseSpeed, PulseLength, FadeLength, MinTransparency/MaxTransparency, CurveSize0/1 and Color. Bolts are pooled — spawn freely.

Rock / Craters

Game.Lightning.ASRockModule — spawns debris/crater rocks that rise and sink with easing. Lazy singleton.

using Game.Lightning;

// center, radius, size, [amount], [angleStep]
ASRockModule.Instance.Crater(hitPoint, radius: 8f, size: 1.8f);
ASRockModule.Instance.Crater(hitPoint, 16.5f, 1.8f, amount: 24, angleStep: 15f);

Camera Shake

Game.CameraFx.ASCameraShaker — additive positional/rotational shake. Put the component on your camera rig; it exposes PositionShake and RotationShake that you add onto your base pose each frame.

using Game.CameraFx;

ASCameraShaker.Instance.Shake(ASCameraShakePresets.Lightning());
ASCameraShaker.Instance.Shake(ASCameraShakePresets.Explosion());
ASCameraShaker.Instance.Shake(ASCameraShakePresets.Bump());

// Apply in your camera LateUpdate:
cam.position = basePos + ASCameraShaker.Instance.PositionShake;
cam.rotation = baseRot * ASCameraShaker.Instance.RotationShake;

Tween Engine

AsgineVFX.Tweening.AS_Tween is a centralized, pooled tween engine for lightweight gameplay and VFX animation. It supports typed interpolation, delays, easing, repeats, forward/backward playback, completion callbacks and three time sources.

Creating and playing a tween

using AsgineVFX.Tweening;

TweenInfo settings = new TweenInfo(
    time: 0.4f,
    style: EasingStyle.Back,
    direction: EasingDirection.Out,
    repeatCount: 0,
    reverses: false,
    delayTime: 0.1f);

TweenFloat tween = AS_Tween.Create(
    v => light.intensity = v,
    0f, 5f,
    settings,
    target: light,
    TweenUpdateMode.Scaled);

tween.OnCompleted = () => Debug.Log("Tween finished");
tween.Play();

Supported value types

AS_Tween.Create(...) has typed overloads for float, Vector2, Vector3, Color, Quaternion, Rect and bool. The supplied setter receives the interpolated value every update.

TweenInfo

Update modes

• Scaled uses Time.deltaTime and follows the game time scale.
• Unscaled uses Time.unscaledDeltaTime, useful for UI and pause menus.
• Fixed uses Time.fixedDeltaTime, useful for physics-related animation.

Safe handles and cancellation

TweenHandle handle = new TweenHandle(tween)
    .OnCompleted(() => Debug.Log("Done"))
    .Play();

if (handle.IsActive)
{
    handle.Pause();
}

handle.Cancel();
AS_Tween.KillByTarget(light); // cancels every tween owned by this target

TweenSequence

TweenSequence is a simultaneous tween group. Calling Play() starts every member together, and the sequence invokes its completion callback after every member has finished. Both Append() and Join() add a tween to this same parallel group; use each tween's DelayTime when individual members should begin later. Cancelling the sequence cancels all members as one unit.

.asg Import

AsgineVFX uses its own .asg model format. Dropping an .asg file into the project automatically builds the contained emitter, beam and trail hierarchy through a ScriptedImporter — no manual import window needed. Older supported container versions are migrated during import; new exports use the current format.

Registry & Wind

ASParticleSystem.ASParticleRegistry — the static hub the render feature reads from. Mostly internal, but exposes global wind:

ASParticleSystem.ASParticleRegistry.GlobalWind = new Vector3(2f, 0f, 0f);
// affects emitters with WindAffectsDrag = true

License & Redistribution

AsgineVFX is licensed software. Purchase, trial access or possession of the package does not transfer ownership of the product or its source, assemblies, tools or package files.

• The package may be used only by the licensed customer and authorized members working on that customer's licensed project.
• The AsgineVFX package, DLLs, native libraries, license file, authoring payload, documentation and extracted parts may not be shared, transferred, sublicensed, sold, uploaded or otherwise provided to third parties.
• Do not place AsgineVFX files in public repositories, shared asset collections, marketplaces, templates or downloadable project sources.
• You may distribute games and applications created with AsgineVFX, including the runtime components required by the compiled product, provided the AsgineVFX package is not offered as a reusable or separately extractable asset.
• A trial or time-limited license permits authoring only for its stated period. Existing runtime content remains usable as technically provided, but this does not grant continued authoring rights after expiration.
• A perpetual sell-version license has no authoring expiration, but all ownership and redistribution restrictions remain fully applicable.
• Modification intended to bypass licensing, expiration, access controls or redistribution restrictions is prohibited.