Particle systems are large collections of small objects that create pseudo-3D visual effects such as clouds and beams.
You have surely seen them, even if you don't know yet.
The vortigaunt's beams for example are based on multiple particle systems.
As engine particles can be more complex and way more detailed then gmod's lua particles, I'd like to show you, how to get into the matter of particle system creation.
This guide however, will be very minimalistic.

Particles can be edited in the source engine tools.
You can access these tools by launching a source engine based game with special parameters.

hl2.exe -sv_cheats 1 -sv_lan 1 -tools -nop4

You can either start Garry's Mod with the parameters above or use games like Half-Life 2: Episode 2 as particle editor base.
At this point, it should be noted, that gmod more likely to crash then hl2ep2 when launched in tool-mode.
Gmod automatically adds addon paths, as well as ALL mounted games.
If you decide to use an ep2 base, you have to edit the gameinfo.txt and add the file paths manually.
You can find it in the ep2 folder, located in *steam/steamapps/common/Half-Life 2/ep2/*
All you need to do, is adding the file path pretty similar to this:

game+mod "C:\YourSteam\steamapps\common\GarrysMod\garrysmod\addons\YourAddon"

After this, start ep2 with the start parameters I mentioned above and you'll be good to go.


First, pick "Particle Editor" in the tools section in the upper left corner.
Then you'll see an interface, similar to that one you can see on the picture above.
The upper left panel shows you the list of particle systems, saved in the currently loaded particly library also known as the .pcf-file.
The upper right panel shows you the current ingame scene and the lower right panel shows you a preview for the current particle system. This doesn't actually need that much explaination, right?
The lower left panel shows the components of the currently loaded particle system.
Those are differed into different sections:

• Base Properties
  
• Renderers
  
• Emitters
  
• Initializers
  
• Operators
  
• Forces
  
• Constraints
  
• Children

In the following tutorial, I'll explain, how to create a basic spark particle.
So don't expect too much...

First, click the "Create" button in the library panel and enter a valid name.
Keep in mind, that other modders may use some not-so-unique names.
The given name should also be logic.
If you create particles for a weapon, you may call it "myweapon_particle001a".
Just a suggestion...

Now, define the texture, the particles should use.
In this example, I'll use a basic spark texture from the Half-Life 2 base.

The next thing to do, would be to reduce the maximum particle count in the base settings.
In this case, I've set it to 32.
Note here, that the maximum particle count will be used by the engine, to determin, how much memory should be allocated for this particle system's rendering opertion.
Lower numbers => better performance.

The next thing to do, would be adding a renderer. Pick "Renderer" in the properties, right-click on the function field and pick "render_sprite_trail".

Now, switch to "Operator" and pick "Movement Basic" in the function list.
(again, right-click and stuff)
To add gravity, select the "Movement Basic" function and change the gravity vector.
The value on the z-axis represents the force, that pulls the particle towards the ground.
In this example, I use -60.

Next, add a "Lifespan Decay" function, so the particle can die. This is more or less something you'll have to do with every particle.

Now for spawning the actual particles.
First, switch to "Emitter" and add an emission function.
For effects, that just appear once, like this one, pick "emit_instantaneously".

Now, we should give the particle a spawn position.
Switch to "Initializer" and pick a positioning function.
In this case, I use "Postion Within Sphere Random".
The engine will automatically try to start at the control point 0, which equals the particle's local (0, 0, 0) position.

We also need to add some velocity.
We could either do that by adding an actual velocity or force generation or by adding a position warp.
In this case, I'll do the second thing.
Add the "Position Modify Warp Random" function

For now, values like -16 to 16 in all directions should be a good starting value.

The particle will look more realistic, if we add more randomized elements.
Adding a randomized lifetime per particle is a good way to start.
Switch to "Initializers" and add a "Lifetime Random" function.
You only need to set the minimum and the maximum values.
Min. 2 and max. 4 should do it.

Another aspect of realsim would be collisions. As collisions are an aspect of physics math, they can have a heavier impact on performance.
Switch to "Constraint" and add a "Collision via traces" function.

Set the collider's collision mode to 3.
This is important, as this is by far the best solution between performance and graphics.
Also, set the collision group from NONE to DEBRIS.
The collision group NONE collides with everything, DEBRIS is exclusive to world geometry.
The collider computes the collision with bounce and slide.
For sparks a bounce value of 0.2 and a slide value of 0.4 are a good starting values.
Now, your particles will be able to touch the world.

Something I'd recommend, especially for sparks, is adding a "Radius Scale" operator.
This function will multiply the radius of every single particle of the current particle system and scales it dynamically between a set start and end time.
For the end time, use 1. As start scale, use 1.2 and for the end scale 0.1.
With this, the particles should spawn relatively large and should become smaller over time.

To make the sparks less obtrusive, I reduce the maximum trail length in the renderer function.
(remember, we used a "render_sprite_trail" function in the "Renderer")
Simply set the maximum value to 8 (or another value, that's a matter of taste or something).

You're done. Congratulations, you've created a particle systems.
Now you just need to save it to a .pcf file.

A lot of things in the field of modding are hard to learn from cratch and it can sometimes be very helpfull to have someone else's work as an example to learn from.
However, this does NOT mean, that you should go out there and re-release other people's work.

Feel free to use my particle resources for learning

You may copy some of the existing particles and edit them.
Keep in mind, that the Source engine loads content in alphabetical order and will override duplicate content.

To prevent unintended override/replacement scenarios, try to give your particles unique names.
For example "grenade_explosion" will most likely be already taken, however "myaddon_grenade_explosion" should be unique enough.

If you end up using any of my content, please credit me appropriately.

https://developer.valvesoftware.com/wiki/Particle
http://wiki.garrysmod.com/page/Global/ParticleEffect
http://wiki.garrysmod.com/page/Global/ParticleEffectAttach
http://wiki.garrysmod.com/page/game/AddParticles
http://wiki.garrysmod.com/page/Global/PrecacheParticleSystem
http://wiki.garrysmod.com/page/WEAPON/DoImpactEffect

Particles can have a very heavy impact on performance.
(or in short, kill your fps)
One very important thing is to avoid "overdraw".
Overdraw is a scenario, with a lot of pixel changes between two frames.
To avoid this, you should use less transparent particles and not too high emission rates.
The engine's particle renderer will work more performant, if you add particle systems as childs to a parent system and spawn the parent only.



You'll have to precache the particle library in the lua addon's startup.
I'd recommend to do this in the autorun.
In this example function, I use the particle we created before as non-overriding impact effect for bullet traces.

Now it's up to you :)

This tutorial is very, very minimalistic, but I gave you the basics to create high detailed effects for your lua addons.
And it's not as difficult, as I might seem to you now.


(energy explosion effect)


(particles on items with dynamic lens flares)


(laser impact with spark emission and rope-based tracer)


(particle base muzzle flash)