Feed aggregator

Format: WAV (PCM)  

Sample Rate: 48 kHz  

Bit Depth: 24-bit  

Channels: Stereo  

Loop Lengths: 30 s / 60 s / 120 s  

Variants: Light / Normal / Heavy  

Total Files: 9 seamless loop files  

Loudness Target: −23 LUFS  

True Peak: ≤ −1.5 dBTP  

Loop Design: Seamless loop boundaries (phase-aligned, click-free)  

Additional Features:  

• Loudness-matched variants for consistent layering  

• Designed for stable and consistent playback across typical use cases  

Have you ever heard subtle clicks or tonal inconsistencies when an ambience loop repeats in your engine?

This pack provides clean and balanced indoor airflow ambience suitable for a wide range of real-time environments. Designed for general-purpose use, it ensures stable looping and consistent tonal balance across long-duration playback.

🎧 Preview

The video preview demonstrates real-time loop behavior and stability.

• Video audio is compressed for streaming and does not represent full fidelity.

• Full-quality 48 kHz / 24-bit WAV files are included.

Why Standard?

This Standard edition is designed for projects that need clean, reliable ambience without stricter runtime requirements.

It provides stable looping and consistent tonal behavior for general real-time use.

This pack is designed to provide:

• Seamless loop boundaries for stable playback

• Balanced indoor airflow character

• Consistent loudness across variants

• Reliable use across common ambience scenarios

For projects requiring stricter runtime control and dialogue-safe integration, an Engine Ready edition is also available.

Core Features

• Seamless looping with stable boundaries

• Clean midrange airflow character

• Low transient activity for unobtrusive playback

• General-purpose ambience for flexible use

Includes

9 seamless loop files total

• 3 variants (Light / Normal / Heavy)

• 30 s / 60 s / 120 s seamless loops

Designed For

• Unity / Unreal Engine

• FMOD / Wwise pipelines

• General indoor environments

• Simulation and XR applications

• General interactive audio use

Use Cases

• Indoor environments (rooms, offices, apartments)

• HVAC and ventilation ambience

• Background ambience layers

• Dialogue-supportive scenes

• Menu screens and calm environments

Compatibility

Compatible with major real-time audio engines:

• Unity

• Unreal Engine

• FMOD

• Wwise

• Custom engines

No additional processing required for implementation.

Format: WAV (PCM)
Sample Rate: 48 kHz
Bit Depth: 24-bit
Channels: Stereo
Duration: 30 s samples
Total Files: 2 audio files
Loop Design: Seamless loop (Engine-Ready sample included)

Are your ambience loops causing clicks, instability, or masking dialogue in real-time engines?

Most ambience loops that sound seamless in a DAW can break under real-time playback conditions.

This evaluation pack allows you to test how ambience actually behaves inside game engines.

🎧 Preview

The preview demonstrates how the loop behaves under real-time playback conditions.

You can observe loop continuity, stability, and tonal consistency over time.

• Video audio is compressed for streaming and does not represent full fidelity

• Full-quality 48 kHz / 24-bit WAV files are included

What’s Included

2 evaluation samples

• Mixed Environment Excerpt (30 s)

Indoor Airflow, Mechanical Rumble, and Deep Tension combined for quick comparison of multiple ambience types in a single file

• Deep Tension — Engine-Ready Loop (30 s)

Seamless loop designed for real-time testing

What You Can Test

• Loop continuity (click-free transitions)

• Stability during long-duration playback

• Dialogue masking and spectral balance

• Real-time engine behavior

Why Engine-Ready?

Even small issues such as loop discontinuities, low-frequency buildup, or spectral overlap can become increasingly noticeable over time in real-time environments.

Resolving and optimizing these issues requires valuable time and effort from experienced professionals.

This pack is designed to demonstrate:

• Stable playback across extended sessions

• Dialogue-safe spectral balance

• Controlled low-frequency energy

• Predictable behavior in real-time systems

Unlike standard ambience loops, Engine-Ready assets are calibrated to ensure predictable and stable behavior under real-time playback conditions.

Important Notes

This is a limited evaluation pack and is not intended for production use.

• Limited sample set (not a full ambience system)

• Does not include multi-length loop structures

• Does not include loudness-matched variants

• Intended for testing and evaluation only

Designed For

• Unity / Unreal Engine testing

• FMOD / Wwise pipeline validation

• Dialogue-heavy environments

• Simulation and XR applications

• Real-time interactive audio workflows

• Developers evaluating real-time audio reliability

Compatibility

Compatible with major real-time audio systems:

• Unity

• Unreal Engine

• FMOD

• Wwise

🔗 Upgrade to Full Engine-Ready Packs

This evaluation sample demonstrates core Engine-Ready behavior.

Upgrade to full Engine-Ready packs for production use:

• Multiple loop lengths (15s / 30s / 60s / 120s)

• Loudness-matched variants (Light / Normal / Heavy)

• Expanded ambience systems

• Stable, dialogue-safe ambience for long-duration playback

Designed for reliable, production-ready performance in real-time audio environments.

Format: WAV (PCM)

Sample Rate: 48 kHz

Bit Depth: 24-bit

Channels: Stereo (Mono variants included for 15 s loops)

Loop Lengths: 15 s / 30 s / 60 s / 120 s

Variants: Light / Normal / Heavy

Total Files: 15 seamless loop files

Loudness Target: −23 LUFS

True Peak: ≤ −1.5 dBTP

Loop Design: Seamless loop boundaries (phase-aligned, click-free)

Additional Features:

• Stereo and mono support for flexible real-time implementation

• Optimized for stable long-duration playback in real-time environments

Have you ever experienced low-frequency ambience becoming muddy, unstable, or difficult to control in real-time systems?

This pack provides low-frequency mechanical ambience engineered for controlled, stable playback in game engines.

Designed as an Engine-Ready ambience module, it ensures predictable performance across long-duration playback and real-time interactive systems.

🎧 Preview

The video preview demonstrates real-time loop behavior and stability.

• Video audio is compressed for streaming and does not represent full fidelity.

• Full-quality 48 kHz / 24-bit WAV files are included.

Why Engine Ready?

Even subtle low-frequency buildup, spectral imbalance, or loop discontinuities can gradually affect clarity, control, and long-term stability in real-time environments.

This pack is engineered to ensure:

• Seamless loop boundaries (click-free transitions)

• Stable long-duration playback behavior

• Controlled low-frequency energy to prevent muddiness and masking

• Consistent loudness profile across variants

• Reliable performance in real-time audio systems

Engine-Ready Design

This package includes short-form loop variants designed for flexible real-time implementation.

• Includes 15-second loop variants for precise timing control

• Stereo and mono versions provided for runtime flexibility

• Suitable for layering, triggering, and adaptive audio systems

Includes

15 seamless loop files optimized for real-time playback

• 3 variants (Light / Normal / Heavy)

• 30 s / 60 s / 120 s seamless loops (Stereo)

• Additional 15 s loop variants (Stereo and Mono)

All files are validated for seamless loop integrity and stable long-duration playback in real-time environments.

Designed For

• Unity / Unreal Engine

• FMOD / Wwise pipelines

• Dialogue-heavy environments

• Simulation and XR applications

• Real-time interactive audio systems

Use Cases

• Industrial environments (factories, machinery rooms)

• Mechanical ambience layers

• Low-frequency background beds

• Technical and system-driven environments

• Dialogue-supportive scenes

Compatibility

Compatible with major real-time audio engines:

• Unity

• Unreal Engine

• FMOD

• Wwise

• Custom engines

No additional processing required for implementation.

Format: WAV (PCM)

Sample Rate: 48 kHz

Bit Depth: 24-bit

Channels: Stereo (Mono variants included for 15 s loops)

Loop Lengths: 15 s / 30 s / 60 s / 120 s

Variants: Light / Normal / Heavy

Total Files: 15 seamless loop files

Loudness Target: −23 LUFS

True Peak: ≤ −1.5 dBTP

Loop Design: Seamless loop boundaries (phase-aligned, click-free)

Additional Features:

• Engine-ready optimized for stable real-time playback

• Stereo and mono support for flexible implementation

• Designed for long-duration runtime stability

• Dialogue-safe spectral balance (controlled midrange energy)

Have you ever noticed clicks, instability, or dialogue masking when using ambience loops in real-time systems?

This pack provides seamless indoor room ambience engineered for stable and consistent playback in game engines.

Designed as an Engine-Ready ambience module, it ensures predictable performance across long-duration playback and real-time interactive systems.

🎧 Preview

The video preview demonstrates real-time loop behavior and stability.

• Video audio is compressed for streaming and does not represent full fidelity

• Full-quality 48 kHz / 24-bit WAV files are included

Why Engine Ready?

Even subtle loop discontinuities, spectral imbalance, or low-frequency buildup can gradually affect clarity, mix balance, and long-term stability in real-time environments.

This pack is engineered to ensure:

• Seamless loop boundaries (click-free transitions)

• Stable long-duration playback behavior

• Dialogue-safe spectral balance (controlled midrange energy)

• Consistent loudness profile across variants

• Reliable performance in real-time audio systems

Engine-Ready Design

This package includes short-form loop variants designed for flexible real-time implementation.

• Includes 15-second loop variants for precise timing control

• Stereo and mono versions provided for runtime flexibility

• Suitable for layering, triggering, and adaptive audio systems

Includes

15 seamless loop files optimized for real-time playback

• 3 variants (Light / Normal / Heavy)

• 30 s / 60 s / 120 s seamless loops (Stereo)

• Additional 15 s loop variants (Stereo and Mono)

All files are validated for seamless loop integrity and stable long-duration playback in real-time environments.

Designed For

• Unity / Unreal Engine

• FMOD / Wwise pipelines

• Dialogue-heavy environments

• Simulation and XR applications

• Real-time interactive audio systems

Use Cases

• Indoor environments (rooms, offices, apartments)

• Background ambience layers

• Dialogue-supportive scenes

• Long-duration playback scenarios

Compatibility

Compatible with major real-time audio engines:

• Unity

• Unreal Engine

• FMOD

• Wwise

• Custom engines

No additional processing required for implementation.

Format: WAV (PCM)
Sample Rate: 48 kHz
Bit Depth: 24-bit
Channels: Stereo (Mono variants included for 15s loops)
Loop Lengths: 15 s / 30 s / 60 s / 120 s
Variants: Light / Normal / Heavy
Total Files: 15 seamless loop files
Loudness Target: −23 LUFS
True Peak: ≤ −1.5 dBTP
Loop Design: Seamless loop boundaries (phase-aligned, click-free)

Additional Features:
• Stereo and mono support for flexible real-time implementation
• Optimized for stable long-duration playback in real-time environments

Have you ever noticed tension ambience masking dialogue or overwhelming a scene during long playback in real-time systems?

This pack provides seamless cinematic tension ambience engineered for stable real-time playback in game engines.

Designed as an Engine-Ready ambience module, it ensures predictable performance across long-duration playback and real-time interactive systems.

🎧 Preview

The video preview demonstrates real-time loop behavior and stability.

• Video audio is compressed for streaming and does not represent full fidelity

• Full-quality 48 kHz / 24-bit WAV files are included

Why Engine Ready?

Even subtle sub-bass accumulation, spectral overlap, or loop discontinuities can gradually affect clarity, mix balance, and long-term stability in real-time environments.

This pack is engineered to ensure:

• Seamless loop boundaries (click-free transitions)

• Stable long-duration playback behavior

• Controlled low-frequency energy for tension balance

• Dialogue-safe spectral balance (controlled midrange energy)

• Reliable performance in real-time audio systems

Engine-Ready Design

This package includes short-form loop variants designed for flexible real-time implementation.

• Includes 15-second loop variants for precise timing control

• Stereo and mono versions provided for runtime flexibility

• Suitable for layering, triggering, and adaptive audio systems

Includes

15 seamless loop files optimized for real-time playback

• 3 variants (Light / Normal / Heavy)

• 30 s / 60 s / 120 s seamless loops (Stereo)

• Additional 15 s loop variants (Stereo and Mono)

All files are validated for seamless loop integrity and stable long-duration playback in real-time environments.

Designed For

• Unity / Unreal Engine

• FMOD / Wwise pipelines

• Dialogue-heavy environments

• Horror and suspense gameplay

• Simulation and XR applications

• Real-time interactive audio systems

Use Cases

• Horror environments and suspense scenes

• Psychological tension layers

• Cinematic build-up and atmosphere

• Dialogue-sensitive scenes

• Long-duration gameplay scenarios

Compatibility

Compatible with major real-time audio engines:

• Unity

• Unreal Engine

• FMOD

• Wwise

• Custom engines

No additional processing required for implementation.

Audio file types: wav

Sample rate: 44100

Bit depth: 24bit

Loopable: Yes

Additional: Stereo

Fantasy Open World RPG Game Music Pack

This Pack Contains:

• 10 Ambient Tracks (+Loops) Tracks with strong, defined mood
• 5 Exploration Tracks (+Loops) Good for calm open world exploration
• 5 Dark Ambient Tracks (+Loops) Perfect to play in dungeons or caves
• 5 Action Tracks (+Loops) Used for Epic Battles
• 5 Light Action Tracks (+Loops) Perfect for Small Encounters & Fights
• 5 City / Town Ambient Tracks (+Loops) Used in Towns, Cities e.t.c
• 5 Night Ambient Tracks (+Loops) Perfect for Night traveling
• 5 Solo Ambient Tracks (+Loops) Tracks for Taverns, Keeps, Castles e.t.c
• 5 UI / Menu Tracks (+Loops) Tracks for UI Elements and Menu's
• 5 Narrative / Cut-Scene Tracks - Tracks for Narrative/Story moments & Cut-Scenes
• 10 Sound Effects

55 Tracks & 10 Sfx total

Everything you need to start your Fantasy RPG game!

All tracks are original and human made, no AI was used in the creation process.

License Info:

Free for commercial use

Youtube / Twitch safe

If you have some questions, contact me at alkakrab04@gmail.com

Bird, rain, night sounds on the youtube video are added for watermarking reasons, you don't have them in the original tracks

• Engine: Unity

• Scenes: 2

  - CuteVectorPlatformer_Demo

  - CuteVectorPlatformer_LevelTemplate

• Total art textures: 95 PNG files

• Total prefabs: 53

• Total scripts: 5 C# files

  - 4 runtime scripts

  - 1 editor utility

• Enemy types: 4

  - Blob

  - Fly

  - Hedgehog

  - Spider

• Collectibles: 1 animated coin set

• Backgrounds: 2

• Terrain sprites: 20

• Platform sprites: 6

• Hazard sprites: 23

• Prop sprites: 5

• UI sprites: 15

• Included file types:

  - .png

  - .prefab

  - .unity

  - .cs

  - .md

• Art style: cute, colorful, vector-style look

• Delivery format: Unity-ready package structure with prefabs, scenes, sprites, and scripts

🎮 Cute Vector-Style 2D Platformer Game Art Pack is a clean and well-organized Unity package for building bright, readable, and playful side-scrolling levels with a polished vector-style look.

✨ This pack is designed for developers who want ready-to-use environment art, enemies, collectibles, and scene building pieces without unnecessary complexity. Everything is sorted into clear folders and grouped into practical prefab categories for faster setup inside Unity.

📦 What’s included

• 2 Unity scenes: a visual demo scene and a gameplay level template

• organized source PNG sprites for environment, enemies, collectibles, and UI

• ready-to-use prefabs for terrain, platforms, hazards, props, enemies, and collectibles

• lightweight helper scripts for simple gameplay presentation and scene setup

🌿 Visual content

• background layers for side-scrolling scenes

• terrain blocks in multiple styles

• platforms including cloud, moving, and wooden variants

• hazards such as spikes, water, and rolling obstacles

• decorative props like trees, flowers, rocks, and mini clouds

• enemy sets: Blob, Fly, Hedgehog, and Spider

• animated coin collectible

• UI sprites for health, controls, and showcase labels

🛠 Practical use

• suitable for 2D platformers, side-scrollers, casual games, and colorful indie prototypes

• useful for quick level mockups, gameplay demos, vertical slices, and marketplace-ready scene presentation

• prefab structure helps speed up scene assembly and content browsing

⚙ Included scripts

• SimpleSpriteAnimator

• PingPongMover2D

• PeriodicSpikeTrap2D

• TimedBreakableBlock

• ArtPackSetupUtility (Editor)

📌 Important note

This package delivers a vector-style visual aesthetic, but the included artwork is provided as PNG sprite assets inside a Unity package.

Number of textures: 30

Texture dimensions: 4096x4096

Polygon count of Character: 63,400

Polygon count of Bow: 2,620

Polygon count of Arrow: 124

Number of meshes: 3

Number of prefabs: 2

Rigging: Yes

Animation count: 29

Animation type list:

UV mapping: Yes

LOD information: No

Types of materials and texture maps: PBR

An animated Snake Archer, 2 skins, 25 animations.

The character is versatile and suitable for a wide range of purposes: it can be used as a main protagonist, enemy, or supporting NPC. It fits perfectly into game projects, cinematics, as well as visualizations and concept presentations in the fantasy genre. To get the tail to behave correctly, you need to use physics or script-based bone position control, depending on your goals and the engine you're working in.

Unity exclusive

The controller and physics are configured, can be either the main character or an enemy.

Includes: Animated Character, green/golden skins. Animated Bow. Arrow. Options to disable mesh: accessories, tiara, quiver, dagger.

Mesh details:

1. Bow - 2,602 faces
2. Arrow - 124 face
3. Snake Archer Accessory - 1,886 faces
4. Snake Archer Clothes - 23,325 faces
5. Dagger - 272 faces
6. Face - 7,847 faces
7. Snake Archer Jewelrly - 12,357 faces
8. Snake Archer Quiver - 17,288 faces
9. Snake Archer Tail - 2,640 faces
10. Snake Archer Tail2 - 10,202 faces

Materials: Clothes, Accessory, Tail, Quiver, jewelrly, arrow, dagger, bow, eye, eyeglass, face, eyelash.

Character Animations List:

1. Aim Bow Idle
2. Aim Bow Idle Down
3. Aim Bow Idle Up
4. Aim Bow Start 1
5. Aim Bow Start 2
6. Aim Bow Start 3
7. Casting1
8. Casting2
9. Casting3
10. Death1
11. Death2
12. Death3
13. GetDamage1
14. GetDamage2
15. GetDamage3
16. GetDamage4
17. Idle
18. IdleBow
19. IdleBowWithArrow
20. MoveForward
21. MoveForwardBow
22. MoveForwardBowWithArrow
23. MoveLeftBowWithArrow
24. MoveRightBowWithArrow
25. Shoot

Bow Animation:

1. Idle
2. Aim
3. Shoot

UV mapping: Yes

LOD: No

Types of materials and texture maps: PBR

Core Architecture

------------------------------------------------------------

NPC = Player Unified Agent

Seamlessly share the exact same logic between players and AI agents.

Runtime Role Switching

Instantly switch control between NPC and Player without duplicating logic or controllers.

------------------------------------------------------------

Vehicle & Squad Interaction

Dynamic Vehicle System

Smooth and realistic real-time vehicle entry and exit.

Advanced Seat Manager

Includes a 3-stage validation system:

• Empty seat validation

• Seat reservation system

• Door conflict prevention

Group Intelligence

Supports squad and group-based vehicle interaction.

Smart Assignment

Slot-based seat assignment with integrated leader-follower logic.

------------------------------------------------------------

Custom Navigation

No NavMesh / No Grid

Fully independent and performance-focused navigation system.

Custom A* Pathfinding

Built from the ground up for large-scale open-world environments.

Runtime Obstacle Avoidance

Dynamic path recalculation based on moving objects and environment changes.

------------------------------------------------------------

Built-in Camera System

No Cinemachine Required

Lightweight standalone camera system included.

Dual Modes

Third-person on-foot and vehicle camera support.

Smooth Transitions

Seamless switching between walking and driving states.

------------------------------------------------------------

Animation & IK System

(Requires Unity Animation Rigging package)

Vehicle IK Integration

Lightweight IK system for realistic interaction.

Driver Details

Hands aligned to steering wheel, with proper foot grounding.

Passenger Realism

Natural hand placement for non-driving characters.

------------------------------------------------------------

Developer & Editor Tools

Editor Waypoint Tool

Full in-scene editing (move, select, delete).

Fast Setup

Quick waypoint placement with optional linking.

Seamless Workflow

Auto-setup support for faster iteration.

Ready to Use

Modular and extensible system with included demo scene.

BRIDGE ENGINE: Open World AI & Interaction Framework

------------------------------------------------------------

Build Open World AI Systems in Minutes — Not Months

Create dynamic NPCs, vehicle interactions, and large-scale simulation systems with a unified AI framework.

Bridge Engine allows you to build complex open-world systems without relying on NavMesh or complicated setups.

------------------------------------------------------------

Bridge Engine is a unified open-world AI framework designed for large-scale and dynamic environments.

It enables NPC behavior, vehicle interaction, and navigation systems to work seamlessly together.

------------------------------------------------------------

🔥 True NPC = Player Architecture

At the core of the system lies a true NPC = PLAYER architecture.

AI agents and player-controlled characters share the exact same locomotion system, interaction pipeline, camera logic, and state flow.

This eliminates duplicated controllers and allows seamless runtime role switching without breaking behavior consistency.

------------------------------------------------------------

Unlike traditional setups, Bridge Engine is built as a systemic gameplay framework, not a collection of isolated features.

------------------------------------------------------------

CORE NAVIGATION SYSTEM (NO NAVMESH / NO GRID)

------------------------------------------------------------

Bridge Engine features a fully custom navigation system designed specifically for open-world scenarios.

• Automatic waypoint discovery via tag-based scanning

• Automatic waypoint connection (no manual linking required)

• Distance-based connection filtering

• Obstacle-aware line-of-sight validation

• Dynamic adjacency graph generation

The system also supports:

• Runtime path recalculation

• Dynamic obstacle detection and avoidance

• Repath cooldown and performance throttling

• Obstacle memory caching

• Batched graph rebuild system

This creates a scalable navigation solution for large and dynamic worlds.

------------------------------------------------------------

BRIDGE ENGINE CORE (CENTRAL AI SYSTEM)

------------------------------------------------------------

Bridge Engine acts as a central orchestration layer connecting:

• Character locomotion

• Navigation system

• Vehicle interaction

• Squad/group behavior

Behavior dynamically adapts based on:

• Player state (on-foot / vehicle)

• Target changes

• Environment changes

• Group size

------------------------------------------------------------

DYNAMIC SLOT SYSTEM (GROUP FORMATION AI)

------------------------------------------------------------

• Automatic slot assignment

• Dynamic slot recalculation

• Collision-aware spacing

• Smooth transitions (no snapping)

• Slot occupancy tracking

Context-based behavior:

• Wide formations (vehicle mode)

• Tight formations (follow mode)

• Auto reset on state change

------------------------------------------------------------

VEHICLE INTERACTION SYSTEM

------------------------------------------------------------

• Real-time vehicle entry & exit

• Smart vehicle detection

• Door & seat targeting

• Multi-agent support

• Smooth state transitions

------------------------------------------------------------

ADVANCED SEAT MANAGER SYSTEM

------------------------------------------------------------

• Seat reservation system

• Door conflict prevention

• Dynamic seat validation

• Separate seat & door states

------------------------------------------------------------

ADVANCED CHARACTER MOTOR

------------------------------------------------------------

• Unified player & AI movement

• Intent-based behavior

• Social avoidance system

• Optimized physics queries

------------------------------------------------------------

BUILT-IN CAMERA SYSTEM

------------------------------------------------------------

• Player ↔ Vehicle switching

• Smooth transitions

• Dynamic zoom

• Collision-aware positioning

------------------------------------------------------------

VEHICLE IK SYSTEM

------------------------------------------------------------

• Hand IK (steering)

• Foot grounding

• Driver/passenger logic

• Smooth blending

(Requires Unity Animation Rigging)

------------------------------------------------------------

EDITOR WAYPOINT TOOL

------------------------------------------------------------

• One-click waypoint creation

• Automatic network generation

• Easy editing workflow

------------------------------------------------------------

PERFECT FOR

------------------------------------------------------------

• Open-world games

• Sandbox simulations

• Open-world gameplay systems

• Companion & squad AI

• Vehicle-based systems

• Systemic AI frameworks

Ideal for developers building large-scale AI-driven worlds.

------------------------------------------------------------

IMPORTANT NOTES

------------------------------------------------------------

• Animation Rigging required for IK

• No NavMesh / No Grid system

• Demo models are placeholders

• Focus is on systems, not visuals

Support & Contact

• Official Website: gmtechstudios.com
• Online Documentation: Quick Start & Technical Guide (Preview)
• Support Email: bridgeengine@hotmail.com

This Package includes:

• 34 VFX: 17 power-ups, each with a corresponding trigger effect.
• Texture Sizes: from 512x512 to 1024x1024.
• Number of Prefabs: 34.
• Number of Shaders: 5 Shaders and 4 SubGraphs.
• All particles are customizable and can be recolored.

Requirements:

• Input System package (required for the demo).
• TextMeshPro Package (required for the demo).
• Timeline package.
• Shader Graph package.

Stylized Powerups brings your game to life with a collection of 17 powerful arcade-style powerups.

DEMO

• All animations are Unity Mecanim Humanoid animations
• Fully compatible with any Humanoid character rig
• Easily retargetable across different character models

The included Weapon Helper System ensures animations adapt naturally to different body types—whether it's realistic proportions, stylized characters, or exaggerated designs (e.g. bulky or cartoon-style characters).

Create dynamic and tactical combat with this high-quality sword & shield animation pack, featuring authentic, motion-captured performances focused on coordinated offense and defense.

Designed for responsive and strategic gameplay, this set combines fluid attacks with natural blocking and guarded stances—perfect for RPGs, action-adventure games, and medieval combat systems.

Animation Overview

The animation set includes a complete combat flow system with seamless transitions.

Idle & Stance:

• Idle #1 (Loop)
• Idle #2 (Loop)
• Combat Idle (Loop)
• Idle → Combat Idle
• Combat Idle → Idle

Combos System: (All combo attacks seamlessly chain into each other or return to Combat Idle.)

• Attack #1 (Loop) → Combat Idle
• Attack #2 → Combat Idle
• Attack #3 → Combat Idle
• Attack #4 → Combat Idle
• Attack #5 → Combat Idle

Skills:

• Skill #1 - Start charging forward with shield
• Skill #1 - Charging forward loop
• Skill #1 - Hit target with shield and stop charging.
• Skill #2 (Loop)
• Skill #3 (Loop)

Shield Block:

• Raise Shiled 
• Block (Loop)
• Hit with shiled

Force Attack System:

• Start Force Attack → Charge
• Charge (Loop)
• Force Attack → Combat Idle

Included Tools

Weapon Helper System:

Easily manage weapon positioning and switching with the included helper script:

• Attach WeaponHelper.cs to your character
• Use WeaponPoint prefabs for hand and carry positions (hip, back, etc.)
• Configure multiple weapon modes (left hand, right hand, sheathed, reverse grip, etc.

Then you could call :

• public void LoadWeapon(WeaponModel _model) // Load weapon
• public void UnloadWeapon() // Unload weapon
• public void SwitchWeaponMode(string _uid) // Switch mode between hold/carry/custom mode

Key Features

• 🎥 Motion-captured
• 🔄 Seamless combo chaining system
• 🎮 Gameplay-ready transitions and loops
• 🛠️ Built-in weapon handling tools

Pairs Perfectly With:

Enhance your workflow and visuals by combining this package with other SoftKitty assets:

Master Character Creator - Character Customization/NPC Creator

Create fully customizable characters that seamlessly integrate with these animations

Master Fantasy Weapons|Sword|Axe|Katana|Bow|Shield|Uchigatana

High-quality weapon models designed to match the animation sets and supported by the included Weapon Helper system

• All animations are Unity Mecanim Humanoid animations
• Fully compatible with any Humanoid character rig
• Easily retargetable across different character models

The included Weapon Helper System ensures animations adapt naturally to different body types—whether it's realistic proportions, stylized characters, or exaggerated designs (e.g. bulky or cartoon-style characters).

Bring true Japanese swordsmanship into your game with this high-quality animation pack, featuring authentic, motion-captured performances by a real traditional Kenjutsu practitioner.

Designed for realistic and historical gameplay, this package delivers precise movement, natural flow, and combat-ready transitions for both Tachi and Uchigatana styles.

Animation Overview

Each animation set (Tachi & Uchigatana) includes a complete combat flow system with seamless transitions.

Idle & Stance:

• Idle #1 (Loop)
• Idle #2 (Loop)
• Combat Idle (Loop)
• Idle → Combat Idle
• Combat Idle → Idle

Combos System: (All combo attacks seamlessly chain into each other or return to Combat Idle.)

• Attack #1 (Loop) → Combat Idle
• Attack #2 → Combat Idle
• Attack #3 → Combat Idle
• Attack #4 → Combat Idle
• Attack #5 → Combat Idle

Skills:

• Skill #1 (Loop) 
• Skill #2 (Loop) 
• Skill #3 (Loop) 
• Skill #4 (Loop) 

Force Attack System:

• Start Force Attack → Charge
• Charge (Loop)
• Force Attack → Combat Idle

Included Tools

Weapon Helper System:

Easily manage weapon positioning and switching with the included helper script:

• Attach WeaponHelper.cs to your character
• Use WeaponPoint prefabs for hand and carry positions (hip, back, etc.)
• Configure multiple weapon modes (left hand, right hand, sheathed, reverse grip, etc.

Then you could call : 

• public void LoadWeapon(WeaponModel _model) // Load weapon
• public void UnloadWeapon() // Unload weapon
• public void SwitchWeaponMode(string _uid) // Switch mode between hold/carry/custom mode

Sheath Alignment System (Uchigatana):

• Automatic blade-to-sheath alignment
• Controlled via animation events (already set up for all clips)
• Can be enabled/disabled dynamically

Key Features

• 🎥 Motion-captured by a real Kenjutsu practitioner
• ⚔️ Authentic Tachi & Uchigatana techniques
• 🔄 Seamless combo chaining system
• 🎮 Gameplay-ready transitions and loops
• 🛠️ Built-in weapon handling tools
• 🗡️ Advanced sheath alignment system

Pairs Perfectly With:

Enhance your workflow and visuals by combining this package with other SoftKitty assets:

Master Character Creator - Character Customization/NPC Creator

Create fully customizable characters that seamlessly integrate with these animations

Master Fantasy Weapons|Sword|Axe|Katana|Bow|Shield|Uchigatana

High-quality weapon models designed to match the animation sets and supported by the included Weapon Helper system

• All animations are Unity Mecanim Humanoid animations
• Fully compatible with any Humanoid character rig
• Easily retargetable across different character models

The included Weapon Helper System ensures animations adapt naturally to different body types—whether it's realistic proportions, stylized characters, or exaggerated designs (e.g. bulky or cartoon-style characters).

Deliver raw power and impact to your combat system with this high-quality war axe animation pack, featuring authentic, motion-captured performances designed for heavy, weight-driven combat.

Built for realistic and immersive gameplay, these animations emphasize force, momentum, and follow-through—perfect for brutal melee systems, dark fantasy worlds, or grounded combat experiences.

Animation Overview

The animation set includes a complete combat flow system with seamless transitions.

Idle & Stance:

• Idle #1 (Loop)
• Idle #2 (Loop)
• Combat Idle (Loop)
• Idle → Combat Idle
• Combat Idle → Idle

Combos System: (All combo attacks seamlessly chain into each other or return to Combat Idle.)

• Attack #1 (Loop) → Combat Idle
• Attack #2 → Combat Idle
• Attack #3 → Combat Idle
• Attack #4 → Combat Idle
• Attack #5 → Combat Idle

Skills:

• Skill #1 - Throw Axe
• Skill #1 - Catch Axe
• Skill #2 (Loop)
• Skill #3 (Loop)
• Skill #4 (Loop)

Force Attack System:

• Start Force Attack → Charge
• Charge (Loop)
• Force Attack → Combat Idle

Included Tools

Weapon Helper System:

Easily manage weapon positioning and switching with the included helper script:

• Attach WeaponHelper.cs to your character
• Use WeaponPoint prefabs for hand and carry positions (hip, back, etc.)
• Configure multiple weapon modes (left hand, right hand, sheathed, reverse grip, etc.

Then you could call :

• public void LoadWeapon(WeaponModel _model) // Load weapon
• public void UnloadWeapon() // Unload weapon
• public void SwitchWeaponMode(string _uid) // Switch mode between hold/carry/custom mode

Key Features

• 🎥 Motion-captured
• 🔄 Seamless combo chaining system
• 🎮 Gameplay-ready transitions and loops
• 🛠️ Built-in weapon handling tools

Pairs Perfectly With:

Enhance your workflow and visuals by combining this package with other SoftKitty assets:

Master Character Creator - Character Customization/NPC Creator

Create fully customizable characters that seamlessly integrate with these animations

Master Fantasy Weapons|Sword|Axe|Katana|Bow|Shield|Uchigatana

High-quality weapon models designed to match the animation sets and supported by the included Weapon Helper system

Number of Audio Wavs: 8

Sample rate / bit rate: 16 Bit, 44,100 Hz

Minutes of audio provided: 14

Pack of Happy Music For Games: Volume 2

❮❮❮❮❮ HERE’S EVERYTHING YOU’RE GETTING WITH THIS PACK ❯❯❯❯❯

• 8 Original high-quality music tracks
• 14 Minutes of Audio in 16-bit / 44.1 Khz WAV format
• Commercial Rights & Royalty-Free License

❮❮❮❮❮ TRACK LIST ❯❯❯❯❯

1. Happiness
2. Good Times
3. Happy Day
4. Fun
5. Joyful
6. Feel Good
7. Positive Life
8. Sunshine

❮❮❮❮❮ YOUTUBE NOTICE ❯❯❯❯❯

Our music is registered with YouTube's Content ID system. If you upload a video featuring our music to YouTube, you may receive this notice: "Copyright-protected content found. The owner allows the content to be used on YouTube." This is not a copyright strike. It is a standard notification that does not harm your channel's status or mute your video's audio. You can learn more about this here: https://composersquad.com/contentid

Core Specifications:

• Unity Version: 6.2 or higher required.
• Dependencies: Unity New Input System (Required).
• Architecture: Assembly Definitions (Asmdefs), C# Generics, Interfaces, and F-Bound Polymorphism.

Package Contents:

• Modules: Core Utility, Platformer State-Machine Controller, Virtual Combat Engine.
• Other: Assembly Definitions, ScriptableObject templates, and example scenes.

Performance:

• Logic-only Virtual weapon entities for zero hierarchy overhead.
• Manual update loops to bypass standard Unity event overhead.

PixelDot2D Core Framework

A No-Magic, Architecturally Structured 2D Foundation

Explicit Control. Decoupled Logic. Contract-Safe Architecture.

Please note, this is not for beginners, this is code first! Targeted for intermediate and above, this is not a drag and drop, and it works, this does not come with editor magic where things just work!

Overview

PixelDot2D is a code-first, architectural framework built for developers who prioritize systems over editor magic. This framework provides a highly expandable, modular foundation that works with you, not against you.

PixelDot2D is built on a low-friction API. Most modules are designed to abstract away complexity through simple calls, ensuring ease of use without sacrificing the power and freedom of a code-first approach.

Built to be evergreen, PixelDot2D relies on core C# and Unity internals. The only requirements are Unity 6.2 and above, and the Unity Input System, utilized for manual polling to maintain explicit control over the execution order, bypassing standard Unity input events.

Sub libraries are isolated into Assembly Definitions, ensuring a clean dependency graph where the Core remains agnostic of specific game implementation. This isn't a drag-and-drop kit, it’s a professional-grade foundation for your next masterpiece.

The Modules

Core

Core is designed to be dropped and used into any project. It handles the universal requirements of game development, such as object pooling, saving and loading, keybinds and so on. Core also includes a variety of utility, such as extension methods to help with everyday usage, such as LookAt2D, while also feeling like it’s a part of Unity.

• F-Bound Polymorphism: Object pooling and generics designed so the Editor cannot physically allow an incorrect prefab assignment.
• BinaryWriter/Reader: Robust save/load systems.
• Input Wrapper: A clean, decoupled abstraction over Unity’s New Input System.
• True Decoupling: Systems are isolated to prevent spaghetti dependencies across your project.

Combat Sub-Library (The Universal 2D Execution Engine)

Weapon systems are often a bloated mess of nested GameObjects and fragile physics. PixelDot2D treats combat as pure mathematical data, giving you absolute control over execution without the hierarchy overhead. This is a comprehensive, genre-agnostic engine capable of handling any 2D combat requirement.

• 100% Virtual Architecture: Weapons do not exist as physical objects. They are logic-only entities driven by manual updates, keeping your hierarchy pristine and your CPU overhead near zero
• Interface Driven: Combat is interface driven, meaning anything can use this weapon system with a small interface implementation.
• The Four Pillars of Execution: Out-of-the-box support for Hitscan, Projectile, Swing (Melee/Arcs), and Circle Cast (AOE). These four Cogs provide the foundation to recreate nearly any attack found in 2D gaming history.
• Infinite Variety (Zero Coding): Mix and match behaviors like Lego bricks. Using ScriptableObjects, you can combine different Cogs to create thousands of unique weapons without writing a single line of new code.
• Composite Weapon Stacking: Effortlessly stack multiple behaviors into a single Master Weapon. Create a shotgun that fires a hitscan blast while simultaneously launching projectiles.
• Built to Expand: The Logic-Kitbash architecture is structured so you can plug in custom Aiming, Gating, Execution, or Virtual Transform logic without ever touching or fighting the base framework.
• Visual Debugging: Virtual doesn’t mean invisible. Integrated Editor Gizmos draw your weapon’s range, arcs, and hitboxes in real-time, providing immediate visual feedback during development.

Platformer Sub-Library (The Metroidvania Controller)

A high-performance actor controller built on a State-Driven Architecture, using Unity’s Rigidbody 2D, while utilizing custom raycasts for specific collision checks (Such as wall climbing, ledge climb, and so on). It uses the Core but remains isolated from it, demonstrating true architectural separation.

• Atomic States: Includes Grounded, Airborne (with Coyote Time/Multi-jump), Wall Climb, Wall Ledge climbing, Climbing, and Gliding.
• Zero-Branching Logic: No massive if/else chains. States are isolated files that talk to a central Brain.
• Progression-Ready: Built-in methods to handle ability unlocking and Metroidvania-style progression.

Who is this for?

This framework is for Intermediate to Senior developers who are tired of all in one, premade game templates that are hard to decouple and use sections of. If you believe that a game is a series of small instructions creating complex results, PixelDot2D was built for you.

Requirements

Unity: PixelDot2D is designed to be evergreen, relying purely on C# and Unity’s built-in systems. It imposes no external dependencies or UI frameworks; only Unity’s New Input System is required. Although fully decoupled, it integrates seamlessly with standard Unity components. Unity version requirement: Unity 6.2+ compatible.

Technical: PixelDot2D assumes you have a solid grasp of C# architecture patterns. It makes extensive use of composition alongside inheritance, interfaces, and generics. Manual Update loops and abstract base structures are core to its design philosophy. This framework expects familiarity.

Code Quality & Architectural Preview

To demonstrate the No-Magic philosophy of PixelDot2D, I have provided a complete, functional look at the Object Pooler via GitHub Gist. This is not a lite version; it is the production-ready code included in the framework. Use it to audit the naming conventions, memory management, and structural safety of the framework before you buy.

View the Gist: https://gist.github.com/PixelDot2D/c89bbeb4a152f954f291fc2ad8ad072b

Support & Prerequisites

Support is provided for framework implementation and bug reports. Please note that PixelDot2D is an advanced architectural tool; a solid understanding of C# fundamentals, including Generics, Inheritance, and Constraints, is required. Support requests regarding basic programming syntax or C# language features fall outside the scope of this framework’s documentation.

• Single fullscreen post-processing pass — O(1) per pixel, no raymarching, no 3D textures

• Analytical Beer-Lambert fog integral with exponential height falloff

• Works correctly when camera is inside, above, or below the fog layer

• Render Graph API native — built for URP 17+ / Unity 6, no compatibility mode

• Volume-driven — all parameters exposed as Volume overrides with blending support

Fog Geometry & Distance

• World-space base height, fog thickness, density, and height falloff controls

• Max render distance with separate distance density multiplier

• Near clip parameter to prevent fog artifacts close to the camera

Colour

• Separate base colour, top colour, and distance colour with HDR support

• Power-curve height gradient for non-linear colour transitions

• Distance colour blend for atmospheric perspective

Procedural Noise

• Value, Perlin, and Simplex noise types — fully procedural, zero texture memory

• FBM with configurable octaves (1–4), lacunarity, and persistence

• XZ scroll speed for animated fog movement

• Vertical influence control for shaping the upper fog edge

Directional Scattering

• Forward-scattering from the main directional light (sun/moon)

• Adjustable intensity, exponent (cone tightness), and scatter colour

Fog Lights

• Point and Spot lights interact with fog — fake volumetric glow effect

• Up to 8 lights per frame from URP culling results

• Logarithmic intensity compression for correct HDR light handling

• Spot cone attenuation and range multiplier controls

• Global intensity slider — one knob to scale all fog light contributions

Compatibility

• Unity 6000.0+

• Universal Render Pipeline 17+

• Requires Depth Texture enabled on the URP Pipeline Asset

• Transparent objects do not write depth — fog renders behind them (standard screen-space fog behaviour)

• Demo scene included

Super Fog adds ground fog to your URP project through a single fullscreen post-processing pass. It uses an analytical Beer-Lambert integral to compute fog density — no raymarching, no 3D textures, no baked data. The result is a volumetric-looking fog layer that runs at constant cost per pixel regardless of fog thickness or scene complexity.

The fog sits at a configurable world-space height and fades vertically using an exponential falloff. You control density, height, base position, and distance range directly from a Volume override, so everything works with URP's built-in blending between volumes. This makes it straightforward to set up different fog zones for interiors, exteriors, swamps, valleys, whatever your scene needs.

Three procedural noise types (Value, Perlin, Simplex) break up the fog shape with scrolling FBM patterns. The noise runs entirely in the shader with no texture lookups, keeping memory usage flat. You can adjust octave count, lacunarity, persistence, scroll speed, and vertical influence to get anything from slow-rolling mist to fast turbulent clouds.

Directional scattering simulates light from the main directional light bleeding through the fog useful for sunrise, sunset, and god-ray-style looks. You set the intensity, tightness, and colour of the scatter independently from the fog colour itself.

Fog Lights let Point and Spot lights in your scene punch through the fog with a fake volumetric glow. The system picks up to 8 visible lights per frame from URP's culling results, compresses their intensity logarithmically, and blends their contribution along the camera ray. No extra passes, no shadow maps just a per-pixel loop inside the same fullscreen shader.

The colour system gives you separate base, top, and distance colours with a power-curve height gradient and a distance blend parameter. Combined with HDR colour support and alpha control, you can dial in anything from thick white ground mist to coloured toxic haze.

Built for Unity 6 and URP 17+. Uses the Render Graph API natively no compatibility mode, no deprecated calls. Setup takes under a minute: add the Renderer Feature, drop a Volume override, and tweak.

• Radial blur god rays running as a URP Renderer Feature
• Built on Render Graph API (URP 17+), no compatibility mode fallback
• Downscaled processing: Full, Half, or Quarter resolution
• 13 exposed parameters through URP Volume system with full blending support
• Automatic main Directional Light tracking via RenderSettings.sun
• Graceful off-screen fade when the light source leaves the viewport
• Sky-only masking option to restrict rays to the skybox
• Adjustable luminance threshold with soft knee for controlling which pixels emit rays
• Multi-iteration ping-pong radial blur for longer, smoother shafts
• Light color multiplication — rays pick up the color of your Directional Light
• HDR output compatible, works with bloom and tonemapping
• Fully procedural shader, no texture assets required
• All parameters accessible from C# at runtime via VolumeManager stack
• Demo scene included

Requires Unity 6000.0+, URP 17+, and Depth Texture enabled on the pipeline asset.

Super Rays adds god rays to your URP project as a post-process effect. It uses radial blur instead of heavy volumetric raymarching. The result looks great and costs a fraction of what true volumetric solutions need.

You drop a Renderer Feature onto your URP renderer, add a Volume override, and tweak a few sliders. That's it. The effect tracks your main Directional Light automatically, fades out when the sun moves off-screen, and blends between Volumes like any other URP override.

The processing runs at reduced resolution by default (half or quarter res), and you control quality through sample count and blur iterations. On a typical 1080p scene, you're looking at 0.05–0.15 ms of GPU time depending on settings. Full resolution with max samples is still under 1 ms.

Everything runs through URP's Render Graph API no compatibility mode needed, no hacks. The shader is fully procedural with zero texture dependencies, so there's nothing extra to manage or break.

Features:

- Radial blur god rays as a URP Renderer Feature

- Built on Render Graph API (URP 17+)

- Downscaled processing: Full, Half, or Quarter resolution

- 13 parameters exposed through URP Volume system with full blending

- Automatic Directional Light tracking via RenderSettings.sun

- Off-screen fade when the light leaves the viewport

- Sky-only masking option

- Adjustable luminance threshold with soft knee

- Multi-iteration radial blur for longer, smoother shafts

- Rays pick up the color of your Directional Light

- HDR output, works with bloom and tonemapping

- All parameters accessible from C# at runtime

- Demo scene included

Requires Unity 6000.0+, URP 17+, Depth Texture enabled on the pipeline asset.

• Requires URP 14+ (Unity 2022.3 LTS or newer)
• RenderGraph API — compatible with URP's forward and deferred renderers
• CPU-side exp(-k·camY) optimization reduces per-fragment cost
• Stencil bit 7 (128) reserved — documented for custom shader integration
• SRP Batcher compatible

Physically-based, fully runtime-controllable height fog for URP. Uses analytic exponential density along the true view ray for accurate horizon fog, altitude falloff, and sky gradients.

Features

• Realistic, physically-inspired height fog that looks natural from every angle, including the horizon and sky
• Dedicated sky fog system for smooth, believable blending between ground fog and atmosphere
• Simple distance controls to fine-tune where fog starts and how it fades into the distance
• Subtle animated fog movement using world-space noise for added depth and life
• Automatically adapts to your scene lighting, supporting seamless day/night transitions
• Full HDR color support with easy opacity control for precise visual tuning
• Centralized controller to adjust all fog settings in real time via scripts or animations
• User-friendly inspector with automatic setup and one-click integration into your renderer
• Works instantly on scene load with no manual setup required
• Advanced masking system ensures correct fog on foliage, water, and transparent materials without visual artifacts
• Built-in shader support for easy integration into custom materials
• Includes ready-to-use example shaders for common use cases like time of day and water

_______________

* Indicates assets not included, but used in screenshots

*Triple Brick - The Big Castle Kit [Link]

*FreshCan3D - Modular Ancient Temple [Link]

*Visual Design Cafe - Nature Renderer 2022 [Link]

*BK - Pure Nature 2 : Meadows [Link]

*Dmitrii Kutsenko - Industrial Set v3.0 [Link]

• Unity Render Pipeline: URP only
• Ocean rendering: chunked, camera-centered surface system for large visible coverage
• Water queries: surface height, surface normal, signed distance to surface
• Shader: custom URP HLSL shader with Classic and Enhanced modes
• Underwater: Lite path plus optional enhanced underwater presentation
• Advanced underwater: optional partial-submersion split mode
• Foam: optional contact/intersection foam in the ocean shader
• Wakes: lightweight pooled wake system with emitter workflow
• Buoyancy: lightweight single-point Buoyancy Lite for props and demo boats
• Editor UX: menu-based rig creation, presets, validation, custom inspectors, zone handles
• Performance focus: designed for practical large-world water, not simulation-heavy rendering
• Customization: chunk settings, wave settings, colors, underwater visuals, wake settings, buoyancy tuning
• Sample/demo content: example boat content and setup-oriented documentation; only advertise full sample scene pack if it is added before release
• Known limitations: one render-driving camera per ocean manager, URP-only, no shoreline simulation, no realistic hull buoyancy, no HDRP/Built-in support

1. Hook
Need ocean water that can cover large open worlds without jumping into heavy simulation, complex setup, or expensive rendering? RenderWave is built for practical, scalable ocean water in Unity URP.

2. What RenderWave Is
RenderWave is a production-oriented ocean system for Unity URP, designed around chunked ocean rendering, data-driven water zones, synchronized CPU/GPU wave logic, and clean runtime/editor workflows. It focuses on game-ready results, not physically accurate simulation.

3. Key Benefits

• Built for large visible ocean coverage at low cost
• Stable water height queries for gameplay systems
• Underwater support with optional enhanced presentation
• Lightweight wake system for boats and moving actors
• Practical setup workflow with presets, validation, and editor tooling
• Clear architecture suitable for real production use

4. Main Features

• Chunked ocean rendering centered around the active camera
• Data-driven water zone system
• Runtime water queries for surface height, normal, and signed distance
• URP HLSL ocean shader with Classic and Enhanced modes
• Optional contact/intersection foam for water-to-geometry readability
• Underwater state handling with stable transitions
• Lite underwater mode plus optional enhanced underwater visuals
• Optional advanced partial-submersion split mode
• Lightweight pooled wake system with emitters
• Buoyancy Lite for floating props and demo boats
• Custom inspectors, quick setup menu items, and validation helpers

5. Use Cases

• Open-world ocean environments
• Retro-inspired or stylized games
• Large exploration scenes
• Boats, floating props, and simple water gameplay hooks
• Teams that need practical water without FFT or simulation-heavy systems

6. What Is NOT Included

• No FFT ocean simulation
• No full shoreline simulation
• No full fluid interaction system
• No realistic naval buoyancy or boat physics package
• No ocean-wide crest foam simulation
• No HDRP support
• No Built-in Render Pipeline support

7. Pipeline Compatibility
RenderWave V1 is URP only. It is not built for HDRP or the Built-in Render Pipeline.

8. Closing Line
RenderWave is for developers who want scalable, game-ready ocean water with strong visual value, clear constraints, and a production-friendly workflow.

• Unity 2022.3 LTS or newer — Universal Render Pipeline only (Built-in and HDRP not supported)

• 5 built-in modules: LightModule, FogModule, RainModule, SkyModule, AudioModule

• ScriptableObject-based weather states — fully serialized, no code required to create new presets

• Coroutine-based transitions with AnimationCurve easing and interruption-safe snapshot system

• Rain particles: world-space simulation, stretch rendering, follows Camera.main automatically

• Skybox blending via runtime material instancing — original asset is never modified on disk

• Audio crossfade using two AudioSources — no clip restart when source and target share the same clip

• Assembly Definition files (.asmdef) for clean build isolation

• Custom WeatherManager Inspector with live transition preview and progress bar

• One-click preset creator: Assets > Create > Dynamic Weather System > Create Sample Presets

• Runtime OnGUI demo UI — no Canvas, no Input System dependency

• Full XML documentation on all public API

• No third-party dependencies

URP Dynamic Weather System is a plug-and-play weather framework built exclusively for Unity's Universal Render Pipeline.

Define weather states as ScriptableObject assets and blend between them at runtime with full AnimationCurve easing. Transitions can be interrupted at any time without visual popping — the system automatically captures a snapshot of the current visual state and transitions from there.

Includes five independent modules: directional light and ambient color control, exponential squared fog, particle-based rain that follows the camera, skybox tint and exposure blending, and a dual-AudioSource crossfade system synced to transition duration.

Four production-ready presets are included (Clear, Rain, Fog, Storm) along with a custom Inspector with live preview, a one-click preset generator, and a runtime demo UI that requires no Canvas or Input System package.

The modular architecture makes it easy to extend: inherit from WeatherModule, implement one method, and add your component as a child of the WeatherSystem GameObject — the manager discovers it automatically.