> This project has been archived as of June 20 - 2026. See the github README as to why ![# Brief Overview](https://cdn.modrinth.com/data/cached_images/a3995d545b7a77db2b2e994e67f2199c5030f8dc_0.webp) Apel stands for **A**nimative **P**article **E**ngine **L**ibrary. Its goal is to give the developer a huge productivity boost by incorporating a powerful animation engine that allows for the management of complex particle animations. Thus the library aims to provide: ![# Why Use APEL?](https://cdn.modrinth.com/data/cached_images/304bf6cb01287cad79fb327400ce6bb0987ee934_0.webp) To put it simply. APEL allows you to fully make these animations with **very few lines of code**:

The key strengths of APEL are specifically: - **Ease Of Use:** The library cuts down the components into its simplest roots. This provides a straightforward and easy to use developer interface, so any developer can use. - **Flexiblity:** Another goal is to make the library as flexible as it can be without ruining the other goal factors. The library allows for composing complex scenes without additional syntactic sugar involved. - **Rich Documentation:** Our team aims for detailed documentation that clearly explains how each feature works. We actively work on improving it, and documentation can be read from java docs or from the markdown documents in github. - **High Performance:** Since the library is meant to be used for creating intricate particle scenes, the library is very optimised and performance friendly.
![## Installation](https://cdn.modrinth.com/data/cached_images/4c6ee5664dcb595c328c262c6d73636db704c8c6_0.webp) ### Developers This section is for developers using APEL as a library. 1. In your ``gradle.properties`` file, add this line: ```java apel_version=0.1.5+1.21.8 ``` 2. In ``build.gradle``, find the top-level ``repositories`` block, and add these lines if you haven't installed any other dependency mods from modrinth: ```java repositories { // ... maven { url = "https://api.modrinth.com/maven" } } ``` 3. Also in ``build.gradle``, add the dependency under the **dependencies** block: ```java dependencies { // ... modImplementation "maven.modrinth:apel:${project.apel_version}" // ... } 4. Refresh gradle (in IntelliJ IDEA, press the gradle icon with a rotate sub-icon) 5. Try to either type ``Apel`` and let your IDE autocomplete it, or import ``net.mcbrincie.apel.Apel``. If all steps are done, everything should work as expected. ### Players Download the mod via your usual means and place it in your ``mods`` folder. ![## Example Of Using APEL](https://cdn.modrinth.com/data/cached_images/ca2658ebff967ba2519176df4c65ae7e6d268d83_0.webp) For a regular particle polygon that moves in a line from one point to another, rotates around the Y axis, and loops by animating between 3 sides to 30 sides, the code looks like this (not a straightforward first example, but showcases the possibilities): ```java AtomicBoolean reverse = new AtomicBoolean(false); ParticlePolygon polygon = ParticlePolygon.builder() .particleEffect(ParticleTypes.END_ROD) .sides(3) .scale(3.0f) .amount(100) .beforeDraw((data, obj) -> { if (data.getCurrentStep() <= 15) { return; } boolean isStepZero = data.getCurrentStep() % 15 == 0; int sides = ApelUtils.getValueFromEasingCurve(obj.getSides()); if (isStepZero && !reverse.get()) { obj.setSides(sides + 1); if (sides >= 30) { reverse.set(true); } } else if (isStepZero && reverse.get()) { obj.setSides(sides - 1); if (sides == 4) { reverse.set(false); } } Vector3f newRot = ApelUtils.getValueFromEasingCurve(obj.getRotation()).add(0, 0.002f, 0); obj.setRotation(newRot); }) .build(); LinearAnimator linearAnimator = LinearAnimator.builder() .endpoint(new Vector3f()) .endpoint(new Vector3f(10, 0, 0)) .particleObject(polygon) .delay(1) .stepsForAllSegments(1000) .build(); ApelServerRenderer renderer = ApelServerRenderer.client((ServerWorld) world); linearAnimator.beginAnimation(renderer); ``` We define the particle object (`ParticlePolygon`) with the particle effect to use, the sides of the polygon, the size of the polygon, and the number of particles to use on the polygon. After that we use the library's ability to modify the object before each frame is rendered. This is via a lambda function that receives some context and the object to be rendered. This example modifies the number of sides on the polygon by checking what step the animation is on, and using that to determine the number of sides the polygon should have. It also shows how to increment the rotation (expressed in Euler angles per axis), in this case a slight rotation around the y-axis on each tick. Note: We extract the value using ``ApelUtils.getValueFromEasingCurve`` for rotation and the number of sides, in our case we know this is not a null value so it works perfectly fine We then create a linear path animator and supply it with the delay in ticks between frames, the starting position of the line, the ending position of the line, the particle object to use, and the number of rendering steps for the animation. Finally, we play the linear path animator and supply it with a renderer instance for server-side rendering. ## Note The mod may be required to be installed client-side depending on if the developer chooses to use Apel's client-side renderer, which optimises the particles way more than the server-side renderer although it requires that people need the client mod to be installed. If they don't choose client-side renderer then no need for the client mod ![## Links / Social Media](https://cdn.modrinth.com/data/cached_images/6a8bbe450d42edfb3b131b87a461a7a8b4b07566_0.webp) - [Github Repository](https://github.com/GitBrincie212/Apel-Mod/tree/main) - [Discord Server](https://discord.gg/tmNGCCPphK) - [Instagram](https://www.instagram.com/_instabrincie212_/)

McBrincie212

RadiantFrame Project