Feed aggregator

• Resolution: 8192 × 4096 (8K)
• Files Included: 12 HDRIs
• Format: .HDR (32-bit high dynamic range)
• Type: Seamless, equirectangular panoramas
• Dynamic Range: Full HDR (excellent for lighting & reflections)
• Engine Compatibility: Unity URP, HDRP, Built-in Render Pipeline
• Use Cases: Skyboxes, environment lighting, reflections, space scenes, sci-fi games, cinematics, VR/AR
• Rendering Source: Fully rendered in native 8K (not AI-generated, not upscaled)

Elevate your Unity environments with this AAA 8K Sci-Fi HDRI Pack, featuring 12 ultra-high-resolution galaxy, nebula, and starfield skyboxes. Each HDRI is natively rendered at 8192×4096, providing exceptional sharpness, clean lighting, and cinematic realism for your Unity scenes.

These HDRIs are fully seamless, equirectangular, and ideal for dynamic lighting, reflections, skyboxes, atmospheric effects, sci-fi scenes, VR/AR experiences, and high-end cinematics.
Nothing is AI-generated or upscaled — every map is produced through native 3D rendering for true AAA quality.

Perfect for developers, artists, cinematic creators, and anyone who needs breathtaking space environments in Unity.

1.Art

Art folder is subdivided into five folders.

A. Materials

Contains 24 various materials used in the game, which can be customized with different colours or sprites.

B. Models:

Contains 3unique 3D models of objects in the game (FBX)

C. Textures:

Contains 18 textures of models that can be applied to materials (PNG)

D. Animations:

Contains 8different character animations

E. Sprites:

Contains 10UI buttons, images and a game icon (PNG)

2. Prefabs

The Prefabs folder includes four main categories with 23 prefabs (Gameplay, Character, Particles and UI folders)

3. Scenes

- Level-1 to 5: the sample levels of the game.

- MainMenu: the starting scene of the game.

4. ScriptableObjects

2different scriptable objects namely Data Storage and UI Data to save and load game data.

5. Scripts

22 Scripts are categorized into three folders (Gameplay, ScriptableObjects and UI), with clear names and functions to ensure easy understanding.

Power Defence Shooter 3D – Game Template

Defend your base and survive against waves of enemies using five powerful upgrades — Double Bullet, Double Player, Machine Gun, Explode All, and Speed Boost. The template includes five ready-to-play levels and makes adding new ones simple and intuitive.

Try the Demos:

• Android APK
• WebGL

Project Highlights:

• Art Assets: 24 materials, 18 PNG textures, 10 UI sprites (including game icon), and 3 3D FBX models.
• Prefabs: 23 ready-to-use and customizable prefabs for characters, enemies, environment, and UI.
• Scenes: Five playable sample levels plus a main menu scene for quick setup.
• Scripts: 22 optimized, well-structured scripts for smooth and scalable gameplay.

Customization:
Easily modify assets, tweak gameplay, or create new levels to suit your project.

Dependencies:
Requires Unity UI/TextMeshPro and Post Processing (installable via Package Manager).

Support:
For assistance or inquiries, visit blackrosedevelopers.com.

Resolution: 2048x2048

Maps included:

- Color

- Normal

- AO

- Height

- Mask

This pack contains:

19 seamless textures

Dependencies

• MemoryPack 1.21.4 (MIT) – downloaded from nuget.org on user consent

MemoryPack’s NuGet package contains pre-compiled Microsoft BCL helpers:

• System.Collections.Immutable © Microsoft Corporation – MIT

Licence: https://licenses.nuget.org/MIT

• System.Runtime.CompilerServices.Unsafe © Microsoft Corporation – MIT

Licence: https://licenses.nuget.org/MIT

• Unity Editor Coroutines 1.x – added via Package Manager on user consent

Both packages are installed automatically or can be added manually.

Component-Based Workflow

• Drag-and-drop Remember Prefab components or use a single Remember Component to manage many at once—no boiler-plate.

Zero-GC Serialization

• Powered by MemoryPack for lightning-fast, version-tolerant binary saves that stay tiny and allocation-free.

Cloud + Local in One API

• One toggle moves all slots to Unity Cloud Save; helper methods handle Unity ID, Steam, Google Play, Apple, Facebook or anonymous sign-in.

Version-Safe Save Migration

• Built-in Migration Manager upgrades old save files automatically after patches—no progress loss, no angry Steam reviews.
• • RestoreSingleGameObject() reloads any still-existing object without reloading the scene.• RestoreDestroyedGameObject() re-instantiates objects that were saved as destroyed—perfect for breakables or pickups.Targeted Restore & Destroyed-Object Restore

Version-Safe Save Migration

SaveablePrefabFactory.Instantiate() spawns + registers runtime prefabs in one line.

Runtime & Pooled Prefab Support

• SaveablePrefabPool auto-manages GUIDs for pooled assets.

Persistent Manager

• One call marks objects DontDestroyOnLoad while duplicate detection keeps your singletons clean.

User Settings Saver

• Saves resolution, DLSS/FSR toggles, FPS cap, audio mixer levels, locale, quality presets, etc., to a separate UserSettingsData file.

Thumbnail & Metadata Slots

• Automatic screenshots and JSON info for slick load menus; optional local mirror when cloud is enabled.

Event-Rich API

• C# events & UnityEvents for slot changes, progress, per-object restore, failures, screenshots, and more.

Editor Tooling

• • Prefab Registry with “🧹 Clean Duplicates”• Batch Migration Actions (meshes, GC2 characters, lights, etc.)• One-click default settings installer & duplicate-resource scanner • Save-Slot Manager window (live status, cancel, timeout guard)

Deterministic Prefab IDs

• Consistent across Editor, build and cloud for safe cross-platform transfers.

Full Source, No DLL Lock-In

• Clean C# code, extensively commented—extend or strip at will.

Pipeline & Platform Agnostic

• Works in Built-in, URP, HDRP; tested on Windows, macOS, Linux, iOS, Android, WebGL, and consoles that support Unity Services.

Minimum Requirements

• Unity 2022.3 or newer.

(Optional expansion modules add deep integrations for Game Creator 2 systems, but the core package is 100 % standalone.)

Crystal Save Core Bundle includes the following Save Modules for:

• Game Creator 2
• Cozy Weather 3
• PixelCrushers Dialogue System
• PixelCrushers Love Hate
• PixelCrushers Quest Machine
• The Visual Engine
• Ultimate Character Controller
• Ultimate Inventory

🔰 Crystal Save — Zero-Code (for Save & Load) Save System for Unity

Crystal Save is a component-based, fully no-code (for Save and Load) save framework that drops into any Unity project—2D, 3D, VR, mobile or desktop—and instantly records scenes, prefabs, runtime objects, player settings and custom components. Other features are an Object Persistent Manager and User Settings Manager.

===| 💬 DISCORD | 📖 DOCUMENTATION | 🎥 VIDEO TUTORIALS |===

😌 How easy?

Add Remember Prefab to your runtime prefab. Done!

Saving & loading now restore that prefab automatically.

Its modular design lets you pick exactly what to persist, from a single inventory bag to a whole open world—no boiler-plate.

• Integrations for Game Creator 2 (all modules), Love/Hate, State Machine, Factions etc. are sold seperately

🧩 Core Feature Set

• Cloud + Local in one API — flip one toggle to move all slots to Unity Cloud Save or Supabase with local mirroring and encryption; helper methods handle sign-in for Unity, Steam, Google, Apple, Facebook or anonymous players. For cloud service compatibility: Save optionaly in JSON Format.
• Why it matters: Ship single-player today, add cloud tomorrow—no refactor. Offline? Local mirror still works.
• Version-safe Save Migration — every save blob carries your game’s semantic version; the built-in Migration Manager upgrades older data on the fly.
• Why it matters: Players keep 40-hour RPG progress after patches, protecting your Steam rating.
• Streaming Deferred Prefabs — Crystal Save can stagger the restoration of deferred prefabs so they only instantiate when a player gets close enough. The DeferredPrefabRadiusStreamer handles distance checks per scene (or globally), caching deferred entries and reviving them on demand. Designer-friendly actions/nodes via Game Creator 2 or Playmaker let you also trigger instantiation via quests, cutscenes, or trigger volumes.
• Why it matters:
• Smooth load times — eliminate huge spikes after loading a save.
• Smarter streaming — additive scenes and global prefabs revive independently.
• Hierarchy-safe — parents and children spawn together, preserving transforms.
• Flexible — pick radius-based streaming for simplicity or manual triggers for narrative control.
• Targeted Restore — load just one GameObject (vendor UI, boss arena, player bag) without reloading the scene.
• Why it matters: Instant respawns, checkpoint pickups, mid-match loadouts—zero hitching.
• Metadata Import (Beta) — bring in save-slot metadata from other Crystal Save titles to continue stories across genres. Drop JSON, base64, or binary blobs into SaveMetadataImportSource; encrypted data needs the matching key. Perfect for cross-game narratives, sequels, and event rewards.
• Why it matters:
• Cross‑game continuity – Players keep a persistent identity across separate releases, strengthening attachment to your universe.
• Marketing hooks – Reward loyal players who’ve finished or explored previous games, driving engagement and retention.
• Easier spin‑offs – Prototype a new genre or platform while still honoring progress from the main series.
• Event distribution – Share promotional metadata blobs via web, email, or physical cards, letting players import limited-time bonuses.
• Pooled & Runtime Prefab Support — objects spawned from a Crystal Save pool or via the custom instantiate method get fresh GUIDs, auto-register, and soft-unregister on despawn. Perfect for bullet-hell shooters, heavy VFX, endless runners.
• Why it matters: Save bullet-hells and VFX storms safely, stutter-free.
• Persistent Manager — one call marks objects DontDestroyOnLoad; duplicate detection stops clone spam across scenes.
• Why it matters: Clean cross-scene persistence without singleton clutter.
• Event-rich API — hooks for slot updates, per-object restore, load progress, failures, screenshots and more.
• Why it matters: Tie saves to UI, analytics or custom logic in minutes—no reflection polling.
• MemoryPack Serializer — ultra-fast, zero-GC binary format smaller and quicker than JSON/BinaryFormatter; used for prefab mods, snapshots and custom blobs.
• Why it matters: Tiny payloads, lightning load times—even on mobile.
• Prefab & Component Diffs — stores only changes (added components, mesh/material swaps, particle timelines, child active states), keeping files tiny even for dynamic characters.
• Why it matters: Huge open-world saves stay megabyte-small.
• Scene-object registry + destroyed-object tracking — resurrect or ignore objects removed mid-play; perfect for breakables, pick-ups, enemy corpses, roguelikes, construction sims.
• Why it matters: Large open worlds get instant respawns and checkpoints with minimal hitching.
• Screenshot & metadata mirroring — auto-thumbnails and optional local mirror even with Cloud Save.
• Why it matters: No internet? You can still load your saves.
• Non-Destructive Save Migration
• Why it matters: Field re-orders or new systems often break naïve formats. Crystal Save auto-patches or calls your converter so players keep progress and you dodge “update wiped my save” reviews on STEAM.
• Optional User Settings (JSON-backed)
• Drop the UserSettingsManager into your bootstrap scene if you want a single JSON to persist resolution, FPS cap, HDRP/URP post-processing toggles, audio mixer volumes and localisation codes.
• • One call saves or loads player options; a second call pushes them live.
• • Works offline and syncs seamlessly when you enable Cloud Save.
• • Totally optional—skip it if you already have a custom options pipeline.
• Genre-specific wins
• • Open-world / RPG: Reload a single quest NPC or dungeon while the map stays live—loads slash in seconds.
• • Roguelike / Survival: Destroy-tracking + prefab pools capture procedural loot and bases, then migrate safely when generation rules change.
• • Shooter / Bullet-hell: Pool-aware GUIDs save active projectiles & VFX with zero stutter; soft-unregister cleans pools between waves.
• • Live-service / MMO-lite: Cloud Save mirrors slots; Migration Manager keeps seasons compatible; MemoryPack stays under quotas.
• • Narrative / VN: Per-object restore reloads only dialogue state—instant skip-ahead & auto-saves.
• What makes it special
• • No reflection-heavy polling—components push their state, leaving CPU for gameplay.
• • Inspector-first UX—one Remember Component collapses many specialised components into a tidy drawer.
• • Deterministic prefab IDs—consistent in editor, build and cloud for safe cross-platform transfers.
• • Full source, no DLL lock-in—customise, extend, ship.
• • Non-destructive save migration—progress survives every patch.
• Drop Crystal Save into your project, tick the boxes you need, and your players’ progress is protected today and after every update.

• Requires:
• Crystal Save Core (v1.6.43 or newer)
• Technical details Frameworks:
• Unity 6 LTS up to Unity 6.4 Alpha | optional Game Creator 2 or Unity Timeline

===| 💬 DISCORD | 📖 DOCUMENTATION |===

Time Crystal is a premium add-on for Crystal Save, designed for creators who want to record, rewind, replay, and branch gameplay events. It transforms saved snapshots into interactive timelines - empowering developers to build ghost races, branching histories, time-travel puzzles, and more.

⚙️ Who It’s For

• Advanced Game Creator 2 & Demo Users: All non-customizing core features work out of the box using the bundled GC2 integration and demos and prefabs - no coding required. Designers can experiment visually through Crystal Save’s node-based setup and ready-made templates.
• Developers & Advanced Users: For teams who want deeper control, TimeMachine exposes clean C# interfaces such as IGhostNavMeshController and ITimeTravelGhostManager, enabling custom ghost AIs, timeline logic, or fully bespoke replay behaviour.

💡 Technical Requirements

Time Crystal targets Power-Users. Integrating it effectively into your project requires advanced Game Creator 2 or C# experience.

🧩 Why It Matters

TimeMachine extends Crystal Save beyond static save/load systems into a dynamic temporal framework - where every decision, movement, and replay can be recorded, reversed, or branched in real time. Perfect for creators building time-loop stories, ghost races, training replays, or timeline-based experiments.

How To Use (Linear Replay):

1. In your Crystal Save Project - Attach the GameObjectTimeMachine to a Scene GameObject
2. Attach the TimeMachineRecorder to a GameObject whose transform data should be snapshotted during runtime. Changing position, rotation and scale is now snappshotted
3. Open Tools > Crystal Save > Time Crystal > Open Time Machine Player
1. Scrub the timelone or replay snapshots

Advanced features like racing against yourself, butterfly effect aka branching story with mulitiple endings, time travelling, multiverse, etc. are shown in the included Demo Scenes.

Time Crystal - Add-On for Crystal Save

Unlock cinematic time control, ghost racing, and branching storylines without rewriting your save logic. Time Crystal expands Crystal Save into a full-featured temporal mechanics framework - built for designers who want to bend time itself.

Rewrite Reality. Frame by Frame.

Time Crystal adds a complete time-control stack on top of Crystal Save’s core serialization. It records, rewinds, and replays gameplay states with frame-accurate precision - from single-object scrubbing to full-scene rewinds. Physics, animation, particles, and audio stay perfectly synchronized for blockbuster-grade “time travel” effects.

Everything runs on the same persistence layer you already trust - encrypted, cloud-ready, and cross-platform.

Designed for Creators & Coders

A dedicated TimeMachine editor window integrates directly into the Crystal Save settings. Producers can switch between ready-made presets like Ghost Racing, Puzzle Solver, or Time Travel with a click. Each preset automatically reconfigures branch logic, resume behavior, and ghost rules, so designers can experiment live - no code edits required.

Integrations

The system ships with complete Game Creator 2 & Unity Timeline coverage, letting you orchestrate temporal gameplay through visual scripting. Please Note: Ghost-Replay of Gestures, States and Skills will be implemented in a later version of Time Crystal

🎮 Gameplay Presets Included

Each configuration is production-ready and fine-tuned for common mechanics:

• Reverse Play Mechanic: Rewinds or fast-forwards gameplay at variable speeds, synchronizing Particle Systems, Audio Clips, Transform Data, and NavMesh movement in real time.
• Why it matters: It delivers authentic, simulation-level time reversal - explosions retract, footsteps unstep, and the world truly rewinds instead of faking it. Designers can build cinematic reversals, temporal puzzles, or undo mechanics that feel seamless and physically consistent, giving players the power to literally control the flow of time.
• Persistent Snapshots: Every frame captured during Reverse Play or TimeMachine playback can be made fully persistent through Crystal Save, preserving object states, timelines, and variables across sessions.
• Why it matters: Time isn’t just visual - it’s now savable. Developers can let players save and reload at any point in a timeline, revisit past decisions, or branch entire universes from a single moment. This turns temporal mechanics into a true persistence layer where every rewind, replay, or divergence can become part of the game’s living history.
• Ghost Agent Time Branching: Lets players hijack the recorded ghost at any moment, steering it via Unity NavMesh Agent or Game Creator 2 Driver to blaze new paths in diverging timelines.
• Why it matters: Ghosts stop being passive replays and become living co-op partners with yourself - an extra set of hands for solving puzzles, distracting enemies, or speedrunning alternate routes without restarting the level.
• Butterfly Effect (Branch-Within-a-Branch Control): Seamlessly swap between your current self and the possessed ghost, all while the TimeMachine tracks branching decisions and keeps every timeline coherent.
• Why it matters: Designers can script layered encounters where players orchestrate multi-agent tactics, choreograph cinematic set pieces, and experiment with “what if” scenarios - all inside a single playthrough.
• Ghost Racing Mechanic: Records every lap while ghost mode replays previous runs in real time.
• Why it matters: Players can race against their own past selves... Just like in TrackMania or Mario Kart... creating powerful retention loops and player-driven competition.
  
• Speedrunning Mechanic: Each run is recorded on a separate timeline with live ghost comparison.
• Why it matters: Builds community engagement by letting players visualize progress, share replays, and refine strategies without external tools.
  
• Puzzle Solver Mechanic: Cooperative timelines where players interact with prior selves.
• Why it matters: Enables mind-bending puzzles similar to Braid or Portal, where time clones and recorded paths become part of the solution itself.
  
• Time Travel Mechanic: Two strict branches (Original and Alt1) allow paradox-free switching.
• Why it matters: Ideal for story-driven or action sequences where the player jumps between two versions of the same level... Chrono Trigger and Titanfall 2 style.
  
• Branching Story Mechanic: Unlimited accumulative branches, no ghost overlap
• Why it matters: Every player choice becomes a recorded alternate path, perfect for visual-novel or choice-based storytelling like Life is Strange or Detroit: Become Human..
  
• Linear Replay Mechanic: Single-branch recording with continuous overwriting.
• Why it matters: Perfect for instant replays, death cams, and highlight reels - turn gameplay into watchable content without third-party systems.
  
• Training Mode Mechanic: Ghosts follow instructor runs while learners record practice sessions.
• Why it matters: Empowers teaching mechanics, rhythm games, or driving schools where players improve by mirroring recorded mastery.
  
• Loop Debugger Mechanic: Repeats a single continuous loop with overwrite behavior.
• Why it matters: Gives developers precise control for balancing roguelite loops or testing respawn behavior under exact repeat conditions.
  
• Experimental Divergence Mechanic: Lightweight alternate timelines without shared history.
• Why it matters: Enables multiple universes and “what if” experimentation - great for narrative prototypes, interactive fiction, and sandbox storytelling.
  
• Combo Training Mechanic: Overlapping ghosts of past attempts in real time.
• Why it matters: Lets players study timing and precision by comparing all previous inputs side by side... excellent for fighting games or rhythm training.
  
• Story Archaeology Mechanic: Continuous branching history showing every player decision.
• Why it matters: Perfect for detective and mystery games, allowing players (and devs) to visualize and retrace complex narrative webs.
  
• Custom Mode Mechanic: Exposes all settings for bespoke experiments.
• Why it matters: Gives studios full creative control to invent new time-based mechanics beyond the curated presets.

Why You Should Use Time Crystal

Time Crystal turns months of R&D into a simple preset switch. Whether you’re building a roguelite loop, a narrative detective game, an RPG with Multiple Endings or an esports replay suite, every timeline behavior is already parameterized, documented, and integrated with Crystal Save’s persistence.

Enter the crimson glow of power with Crimson VFX, a collection of stylized spell effects born from energy, ritual, and intensity. Each effect radiates motion and contrast, designed to feel bold and mystical without losing clean readability.

These effects are built for URP, HDRP, and Built-in pipelines, ensuring easy setup and stable performance across platforms. With one unified shader and a curated art direction, you’ll get plug-and-play visuals ready to bring depth and motion to your magical scenes.

Explore a variety of circles, sigils, and energy eruptions, perfect for fantasy, combat, or ritualistic environments.

✨ Key Features ✨

• Minimal setup — easy to plug into your own meshes and books;
• 1 Shader for all particles;
• Includes one asset overview scene, and a contextual example of usage;
• Compatible with ALL rendering pipelines;
• Consistent stylized art direction;
• Drag, drop, and cast your spell!

Features:

* 17 BGM in ogg, m4a, and wav file formats.

* 5ME or SE in ogg, m4a, and wav file formats.

RPG Maker series containing 17 unique tracks and 5 short music effects. 

The compositions provide a unique atmosphere and feel to the users own creations. 

This collection focuses on a variety of themes, such as dark, emotional, and mysterious. The music works best when paired with the original collection ‘Harmonic Realms’, providing a more diverse range of choice.

•Instruments; pianos, church organs, cellos, flutes, trumpets, violins, taikos, drums, harps, and many more!

•Tracks; 10 thematic, 3 villages, 2 adventure, 2 castle, 5 ‘resolve’ or ‘encounter’ short pieces.

•Entirely original compositions inspired by popular RPGs of the 90s.

Contents:
Featuring 10 tracks inspired by battles and dungeons
Battle: 5 tracks
Dungeon: 5 tracks

"Battle & Dungeon Anthems Vol.02" is the second volume in a music asset collection featuring 10 BGM tracks perfect for RPG battle and dungeon scenes.
With a fantasy-inspired tone, the collection includes a variety of compositions—from grand orchestral pieces to intense rock-style battle themes—bringing a dramatic atmosphere to your game world.

• Number of materials: 2 PBR materials, one for the tracks and one for the rest of the tank. With additional materials for the various skins.
• Texture dimensions: 4K
• Polygon count: around 50K
• Rigged: Yes
• Animated: Yes, a demo animation is provided to showcase the model.
• UV mapping: Yes
• LODs: No

World-War 2 era M5A1 Stuart, game-ready, rigged, animated and low-poly. Comes with 2 different skins.

This model is rigged for easy animation of the main parts: gun, wheels, etc. Tracks deform with the wheels as they move up and down. Tracks can be animated with UV scrolling in your game engine.

This model comes with gorgeous 4K textures showing some wear and tear of a battle-tested vehicle.

A demo animation is provided to showcase all the moving parts of the model. Using a tank controller is recommended to animate the various parts with physics.

The pack at a glance:

• Audio file types: WAV Format.
• Sample Rate: 44.1 kHz.
• Bit Depth: 24 bit.
• Loopable: Yes.
• Additional: Stereo.
• Number of Beats: 20.
• Created for the: background motion, ambient rhythm, subtle texture.

Need to provide credit: No.

Focused on clean, rhythmic minimalism this pack provides soft percussion loops that add motion and texture without overpowering your scene. Great for stealth, puzzle, or ambient city environments. Each loop combines crisp snares, low toms, and hi-hats with plenty of space for dialogue or ambient layers.

The pack at a glance:

• Audio file types: WAV Format.
• Sample Rate: 44.1 kHz.
• Bit Depth: 24 bit.
• Loopable: Yes.
• Additional: Stereo.
• Number of Beats: 20.
• Created for the: sci-fi, factory, dystopian, or cyberpunk action scenes.

Need to provide credit: No.

Industrial Mechanics brings aggressive metallic percussion loops inspired by futuristic machinery and factory ambiences. Expect metallic stomps, mechanical pulses, and rhythmic clangs that fit perfectly into cyberpunk, dystopian, or industrial environments.

The pack at a glance:

• Audio file types: WAV Format.
• Sample Rate: 44.1 kHz.
• Bit Depth: 24 bit.
• Loopable: Yes.
• Additional: Stereo.
• Number of Beats: 24.
• Created for the: atmospheric layers, ambient games, exploration scenes.

Need to provide credit: No.

Ambient Perc Layers provides subtle, evolving percussion designed to sit beneath soundscapes or environmental music. With slow-moving hits, reverbed shakers, and spacey toms, this pack enhances immersion without dominating the mix. Ideal for cinematic ambiences, exploration, or meditation games.

The pack at a glance:

• Audio file types: WAV Format.
• Sample Rate: 44.1 kHz.
• Bit Depth: 24 bit.
• Loopable: Yes.
• Additional: Stereo.
• Number of Beats: 20.
• Created for the: tribal, survival, fantasy, nature ambience.

Need to provide credit: No.

A collection of tribal rhythms and natural drum ensembles inspired by world percussion. Includes deep toms, hand drums, shakers, and ceremonial grooves that add organic intensity to your project. Perfect for survival, fantasy, or nature-based games that need earthy rhythmic foundations.

The pack at a glance:

• Audio file types: WAV Format.
• Sample Rate: 44.1 kHz.
• Bit Depth: 24 bit.
• Loopable: Yes.
• Additional: Stereo.
• Number of Beats: 20.
• Created for the: racing, combat, cyberpunk action, intense gameplay.

Need to provide credit: No.

Breakcore Riot brings distorted breakbeats, glitchy fills, and fast chaotic percussions designed for high-tempo action. Ideal for cyberpunk, racing, and extreme gameplay sequences. Every loop hits hard, full of dynamic compression and energy that can instantly boost adrenaline in your scenes.

The pack at a glance:

• Audio file types: WAV Format.
• Sample Rate: 44.1 kHz.
• Bit Depth: 24 bit.
• Loopable: Yes.
• Additional: Stereo.
• Number of Beats: 20.
• Created for the: action, combat, trailer, epic sound design.

Need to provide credit: No.

A high-impact percussion pack featuring heavy taikos, low toms, and cinematic hits designed for trailers, battles, and cutscenes. Perfect for adding intensity, tension, and dramatic power to any action sequence or reveal moment. Each file is mixed and mastered for clear low-end impact and can be layered easily with other sound elements.

The pack at a glance:

• Audio file types: WAV Format.
• Sample Rate: 44.1 kHz.
• Bit Depth: 24 bit.
• Loopable: Yes.
• Additional: Stereo.
• Number of Beats: 20.
• Created for the: nature, exploration, ambient, or world-inspired games.

Need to provide credit: No.

Organic Touch offers hand-crafted drum loops featuring shakers, bongos, cajóns, and wooden percussive textures. Designed to feel alive and dynamic, these rhythms enhance nature scenes, exploration levels, or story-driven worlds where realism matters.

The pack at a glance:

• Audio file types: WAV Format.
• Sample Rate: 44.1 kHz.
• Bit Depth: 24 bit.
• Loopable: Yes.
• Additional: Stereo.
• Number of Beats: 20.
• Created for the: action, racing, and high-tempo gameplay.

Need to provide credit: No.

An explosive pack of jungle and drum-and-bass breaks, filled with chopped rhythms and syncopated fills. These loops are crafted for developers who need intensity and momentum perfect for combat, speed, or chase sequences.

The pack at a glance:

• Audio file types: WAV Format.
• Sample Rate: 44.1 kHz.
• Bit Depth: 24 bit.
• Loopable: Yes.
• Additional: Stereo.
• Number of Beats: 20.
• Created for the: action, racing, and urban-style games

Need to provide credit: No.

This pack focuses on modern trap and 808-based drum loops, delivering punchy kicks, crisp hi-hats, and rolling snares that create dynamic rhythmic drive. Built for fast-paced gameplay such as racing, shooters, and sports titles, every loop hits with clarity and power.

60 total audio files:

• 10 WAV files with full track + Unity-recognized loop
• 10 WAV files containing only the Intro to seamlessly transition into the corresponding Loop file
• 10 WAV files containing only the Loop section
• 30 corresponding OGG vorbis versions included for the space-conscious developer (NOTE: For out-of-the-box seamlessly looping the OGG tracks, use the separated versions. At the time of writing, Unity does not natively recognize loops in OGG files.)
• 10 .txt files detailing the loop points for each track in samples

Sample rate: 44.1kHz

Bit depth: 16 bits

Stereo

This package contains two versions of each track for maximum flexibility:

• Full plug & play WAV files are ready for use immediately. Simply drag them into an Audio Source with 'Loop' enabled, and you're done! The intro will play once, then continuously and seamlessly loop the main section.
• Split Intro and Loop files for greater control via scripted events, an advanced audio system, or simple preference. This is the recommended method for using the OGG versions.

10 text files are also included containing the loop points (in samples) for each full audio track.

Track List:

1. Delightful Dawning
2. Flourish & Resolve!
3. Sunlit Serenity
4. Abyssal Agitation
5. Ceremony of Consequence
6. Arid Echoes
7. Unraveling Dreams
8. To Fate's Edge
9. Aegis Aligned
10. The Storied Path

Feel free to contact with any collaboration inquiries, issues, or just to say hello ♥

Key Features:

• Mecanim to DOTS conversion via baking
• GPU compute shader skinning for deformation
• State machine with parameter-driven transitions
• Blend trees: 1D, 2D Directional, 2D Cartesian, Direct
• Automatic LOD with temporal frame distribution
• Blend shape support (baked and runtime)
• Animation events with frame-accurate detection
• Burst-compiled systems for all animation logic
• Shared bone blob assets for memory efficiency
• Zero runtime allocations with blob asset architecture
• Full runtime control API (Burst-compatible)
• Debug visualization for development
• Sample scene with working examples
• Complete documentation and tutorials

Supported:

• SkinnedMeshRenderer with bone weights
• Animator Controller (base layer)
• Animation clips (Generic, Humanoid, Legacy)
• Parameters: Float, Int, Bool, Trigger
• Transitions with conditions and exit time
• Blend trees with threshold/position blending
• Animation events
• Blend shapes (morphs/shape keys)

Limitations

• Base layer only (no multiple layers)
• No root motion
• No humanoid retargeting
• No IK/constraints at authoring (can add custom IK systems)
• Maximum 8 motions per blend tree

Animecs converts your existing Animator Controllers to DOTS-compatible animation systems with GPU compute skinning. Keep your Mecanim workflow, get DOTS performance.

| Documentation | Discord | Email Support |

The Problem

Unity DOTS lacks native animation support. Building state machines, blend trees, and LOD systems from scratch takes weeks. Bridging GameObject animators with entities defeats the purpose of DOTS.

The Solution

Animecs reads your Animator Controller and bakes everything to pure ECS:

• States and transitions become blob assets
• Bone matrices pre-sampled for GPU skinning
• Parameters drive runtime transitions
• LOD automatically reduces update frequency
• Blend shapes supported (baked or runtime)

Right-click your prefab, bake, done. Your animation logic converts in seconds.

Performance by Default

• GPU Skinning - Compute shader deformation, tens of thousands of characters per frame
• Shared Bone Data - Identical skeletons reference the same blob assets
• Automatic LOD - Distance-based updates (High/Medium/Low/Off) with temporal distribution
• Burst Compiled - All systems optimized with SIMD
• Zero Allocations - Blob assets eliminate runtime garbage collection

Familiar Workflow

If you know Mecanim, you know Animecs:

• Same states, same transitions, same blend trees
• Standard Animator Controller authoring
• Animation events with frame-accurate detection
• Float, int, bool, trigger parameters
• 1D and 2D blend trees (directional, cartesian, direct)

No custom state machine code. No manual bone matrix sampling. No performance guesswork.

What You Get -

State Machines - Parameter-driven transitions with exit time, duration, blend curves

Blend Trees - 1D, 2D Simple Directional, 2D Freeform Directional, 2D Freeform Cartesian, Direct blending

LOD System - Configurable distance thresholds and update frequencies. Entities update at 1/8th rate when distant.

Blend Shapes - Pre-baked from animations or runtime override for procedural control

Animation Events - Fire code at specific frames. Perfect for footsteps, weapon hits, effects.

Runtime Control - Play states, set parameters, query animation data. Full Burst-compatible API.

Debug Visualization - Optional overlay showing state, time, LOD level, blend progress

Use Cases

• Large crowds and armies
• Open-world NPCs
• RTS unit animations
• Battle royale character counts
• Any scenario requiring 100+, 1000+, 10,000+ animated characters

Animecs focuses on what DOTS does best: performance at scale. If you need to animate crowds without writing custom state machines, Animecs solves that problem.