Feed aggregator

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.

Features:

• Full Humanoid and Modular character support.
• Automated Ragdoll generation with smart joint connection.
• JSON-based preset system for easy data porting.
• Real-time Scene View Gizmos for precise collider editing.
• Optimized Editor UI for fast workflows.
• Clean C# Code: Easy to extend or integrate with your existing damage systems.

Technical Specifications:

• Unity Version: Supports Unity 2021.3 LTS, 2022.3 LTS, and Unity 6 (6000.0+).
• Render Pipelines: 100% compatible with Built-in, URP, and HDRP.
• Dependencies: None. No external packages required.
• Platform Support: Works on all platforms supported by Unity (Windows, Mac, Linux, Android, iOS, Consoles).

Documentation & Support:

• Comprehensive PDF Manual included in the package.
• For bug reports or feature requests, contact: deedleedev@gmail.com

Hurtbox Setup Tool

The ultimate end-to-end solution for managing collision-based damage systems and Ragdolls in Unity.

Stop wasting hours manually creating colliders, adjusting joints, and setting up damage logic. The Hurtbox Setup Tool automates the most tedious parts of character development, allowing you to focus on gameplay. Whether you're building a fighting game, a third-person shooter, or a physics-based simulation, this tool provides a professional, high-speed workflow for both Humanoid and Modular characters.

🚀 Key Modules

• Hurtbox Setup: Automatically fit Box, Sphere, or Capsule colliders to bone bounds. Includes a "Modular Mode" for non-hierarchical character parts.
• Integrated Ragdoll Setup: Generate a full physical rig (Rigidbodies and CharacterJoints) with one click. The tool smartly auto-connects joints to the nearest parent.
• Damage Multipliers: Create custom groups (e.g., Head, Limbs, Torso) with scaling values to synchronize damage logic across body parts instantly.
• Collider Editor: A dedicated interface to fine-tune all character colliders in one place without digging through the Hierarchy.
• JSON Preset System: Export your entire setup to a JSON file. Perfect for batch-processing multiple characters or sharing configurations across different projects.

📦 Demo Content & Compatibility

To ensure an immediate "out-of-the-box" experience, the package includes a demo scene featuring a 3D model from Unity's official Starter Assets.

• Note: This model is used as a static structural reference to showcase the tool's features.
• Lightweight: Character controller scripts, Input System, and Cinemachine are NOT included or required. The tool is dependency-free.

Unity 6 Support.

Demo scenes included with pre tuned prefabs.

Description and Features:

Bring your characters to life with the Self-Balancing Active Ragdoll System, a complete physics and Procedural Animation locomotion and animation framework. Perfect for physics sandboxes, brawlers, and highly interactive VR experiences.

• One-Click Generation: Simply attach the ActiveRagdollBrain to any Humanoid character and click "Generate". The system automatically duplicates meshes, configures joints, and maps all procedural solvers.
• Center of Mass Balancing: Shifts the character's Center of Mass, leaning into turns and fighting to stay upright against physical impacts.
• Procedural Gait & IK Stepping: The IKSolver predicts foot placement based on velocity, automatically stretching strides, gluing feet to the floor to prevent skating, and aligning ankles to uneven terrain.
• Dynamic Pose Syncing (PID Muscles): Characters can take hits and dynamically lose muscle tension, transitioning smoothly into a ragdoll fall and automatically running a procedural get-up sequence.
• Character Controller: Includes a character controller with strafing
• Modern-Style Robotics: Includes a Robotic Arm Animator that procedurally swings arms based on foot separation and velocity.
• Autonomous AI Navigation: Includes a robust Waypoint System featuring dual-mode AI—use simple obstacle avoidance for open rooms or a dedicated Maze Solver with emergency sweeping sensors for tight corridors that can solve mazes.
• Rigged Robot Character included: A techy and high-end robot model is included with the package.
• Demo: Demo scenes available with fine tuned prefabs
• Unity 6 Support

Requirements & Dependencies:

• Requires a valid Humanoid rigged character with an Animator component.
• Unity 2022.3 and above

To ensure you get the best results, please note the following technical limitations:

• Tuning Required: Physics are complex. While the system provides a robust foundation, different character proportions and weights will require manual tweaking of the RagdollTuningProfile (Springs, Dampers, and Hover Forces) and in the main brain script to achieve perfect stability.
• Humanoid Only: The one-click auto-generation and dynamic bone mapping rely heavily on Unity's Humanoid Avatar bone structure. Generic or multi-legged creatures are not currently supported out-of-the-box.
• No Jumping Behavior: We are currently working on implementing jumping functionality
• Doesn't Handle Stairs well.

Revised Technical Section

Core Architecture:

• Static Implementation: No persistent GameObjects, singletons, or "Manager" prefabs required. Access the engine anywhere via static calls.
• Decoupled Compilation: Includes a pre-configured Assembly Definition (.asmdef) to ensure fast project re-compile times and modularity.
• Namespace Protection: All logic is contained within Canley.Utility.Haptics to prevent naming collisions with other assets or native plugins.

Native Bridge Integration:

• iOS: High-fidelity bridge to Objective-C using UIImpactFeedbackGenerator and UINotificationFeedbackGenerator.
• Android (Triple-Tier Engine):
  Flagship (API 30+): Leverages Composition Primitives for ultra-sharp, mechanical feedback on modern actuators.
  Modern (API 26-29): Utilizes VibrationEffect and "Active Braking" waveforms for crisp tactile responses.
  Legacy: Precise millisecond pulsing for maximum backward compatibility.
• Automatic Permission Injection: Includes a dormant method strategy that forces Unity to include the <uses-permission android:name="android.permission.VIBRATE" /> in the final manifest without manual user intervention.

Unity 6 & New Input System:

• Input Migration Tool: Includes an automated Editor utility to update EventSystem components for the New Input System (migration occurs on a per-scene basis for safety).
• TMP Resolution: Built-in guidance and compatibility for Unity 6 TextMeshPro resource transitions.

Build Footprint:

• Minimal Impact: Total asset size is <1Mb.
• Conditional Compilation: Extensive use of #if preprocessor directives ensures that mobile-specific code is stripped from PC/Mac builds, keeping your desktop builds clean and error-free.

Package Includes:

• Core Native Bridges (C#, Objective-C, Java).
• 7 Qualitative Haptic Styles.
• Interactive Demo Scene & Mobile UI Shaders.
• Full C# Source Code.
• 8-Page Comprehensive PDF Manual.

Intuitive, Design-First Haptic Logic

Standard haptic solutions often force you to speak the language of hardware branding (like NotificationSuccess or ImpactLevelLow). Canley Haptics Lite replaces esoteric jargon with qualitative, "Plain English" styles like SoftBump, TriplePulse, and HeavyBump. Designed to be "light on its feet," this asset provides a premium, zero-config bridge to the native iOS Taptic Engine and the modern Android vibration ecosystem.

Key Features:

• One-Line Implementation: Trigger any haptic style with a single static call: CanleyHaptics.Trigger(HapticStyle.MediumBump).
• Flagship Android Sharpness (API 30+): Now utilizes Android Composition Primitives. On supported flagship hardware (Pixel 4+, Samsung S20+), this triggers specific mechanical motor instructions for "Apple-sharp" tactile feedback.
• Active-Braking Waveforms (API 26+): Uses precision micro-timings and active braking to eliminate "fuzziness" on modern Android actuators, ensuring patterns feel like distinct clicks rather than a generic buzz.
• Zero-Config Android Permissions: Our internal bridge automatically handles the VIBRATE permission injection during the build—no manual Manifest editing required.
• Editor Simulation: Working without a device? The console prints color-coded, rich-text logs so you can verify your haptic logic visually during playtests.
• Unity 6 Verified: Fully compatible with the latest engine version, including automated fixes for New Input System migration and TMP resource errors.

Best For:

• UI/UX Intensive Apps: Perfect for adding tactile "weight" to buttons, sliders, and scroll wheels.
• Hyper-Casual & Puzzle Games: Enhance the "juice" of your game with satisfying physical feedback for every interaction.
• Prototyping: The fastest way to get professional haptics into a project without the bloat of larger SDKs.

Technical Specs:

• iOS: iPhone 7+ (Taptic Engine).
• Android: API 30+ for ultra-sharp Composition Primitives, API 26+ for high-fidelity waveforms, and an intelligent legacy fallback for older hardware.
• Footprint: Extremely lightweight with zero namespace pollution.

Technical Specifications

Visual Scripting Integration:

• Custom Node Library: Fully integrated nodes for triggering haptics, toggling global states, and reading engine status.
• Haptic Style Selector: A dedicated literal node featuring a custom header-integrated dropdown for rapid design iteration.
• Dynamic Output Variables: Nodes provide real-time data (Style Played, Is Enabled) to drive dynamic UI and feedback logic.
• No-Code Configuration: Custom nodes are automatically included in the Visual Scripting fuzzy finder; no manual Type Option management required.

Core Architecture & Performance:

• Static Implementation: No persistent GameObjects or "Manager" prefabs required. The engine is accessible via C# static calls or Visual Scripting nodes.
• Mobile-First Footprint: Total asset size is <1Mb. Extensive use of conditional compilation ensures mobile-specific code is stripped from PC/Mac builds.
• Namespace Protection: All logic is contained within Canley.Utility.Haptics to prevent naming collisions.

Native Bridge Integration:

• iOS: High-fidelity bridge to Objective-C utilizing UIImpactFeedbackGenerator and UINotificationFeedbackGenerator.
• Android (Triple-Tier Engine):
  Flagship (API 30+): Leverages Composition Primitives for ultra-sharp, mechanical feedback on modern actuators.
  Modern (API 26-29): Utilizes VibrationEffect waveforms for crisp tactile responses.
  Legacy: Precise millisecond pulsing for maximum backward compatibility.
• Automatic Permission Injection: Automatically ensures the VIBRATE permission is included in the final Android manifest without manual intervention.

Unity 6 & Input Compatibility:

• Unity 6 Verified: Fully optimized for the new integrated Visual Scripting workflow and TextMesh Pro resource requirements.
• Input Migration Tool: Automated Editor utility to update EventSystem components for projects using the New Input System.

Package Includes:

• Core Native Bridges (C#, Objective-C, Java).
• 7 Qualitative Haptic Styles (Soft Bump through Triple Pulse).
• Custom Visual Scripting Node Suite.
• Masterclass Demo Scene featuring color-coded graph architecture.
• 15 Pages of Documentation (Core User Manual + Visual Scripting Module Guide).

The Premium, Qualitative Haptic Solution for Unity Mobile — Now with Full Visual Scripting Support.

Here are intuitive, plain English haptics that help you see just what your end-users will feel.

Canley Haptics Lite is a high-performance, zero-allocation engine that replaces complex vibration calls with plain-English presets like Soft Bump and Triple Pulse.

This Visual Scripting Edition includes the full C# API plus a premium suite of custom nodes, allowing you to build professional tactile feedback directly in your graphs without writing a single line of code.

Why Choose Canley Haptics?

• Qualitative Mapping: Trigger "Styles" that automatically route to native iOS Taptic Engines and Android 11+ Composition Primitives for "Apple-sharp" feedback on flagship devices.
• Haptic Style Selector: A custom literal node featuring a header-integrated dropdown. Pick your tactile vibe directly on the node—no more navigating the inspector.
• Educational Demo Scene: Includes a masterclass in clean graph architecture. Learn to use modular event arguments, color-coded logic groups, and rhythmic "Pulse Loops" with built-in safety fail-safes.
• Unity 6 Verified: Fully optimized for the latest engine versions and integrated Visual Scripting workflows.
• Zero Config: Nodes appear automatically in the fuzzy finder. No manual "Type Option" management required.

Platform Support

• iOS: iPhone 7 and newer (Taptic Engine).
• Android: API Level 30+ for Composition Primitives, with intelligent fallbacks for older devices.
• Universal: One node handles both platforms automatically.

Documentation

Includes quick setup guides followed by 15 pages of detailed, tutorial-style documentation across two manuals, covering everything from initial setup to advanced tactile design theory.

Support: swadie@me.com

KEY FEATURES:

• Infinite Scalability: Powered by a custom SDF shader. Zero pixelation, no matter how much you scale your UI.
• Advanced Corner Radii: Adjust all corners uniformly, or tweak the Top-Left, Top-Right, Bottom-Right, and Bottom-Left corners independently.
• Intuitive Scene View Controls: Drag the visual handles directly in your Scene View to adjust corner sizes and gradient start/end points on the fly!
• Rich Fill Options: Choose between Solid Color, Linear Gradients (with visual handlers), or Image Tinting.
• Stroke & Border System: Fully adjustable stroke width, color, and alignment (Inside, Center, Outside).
• Built-in Shadow Effects: Add multiple, stackable Drop Shadows and Inner Shadows. Control the blur, spread, offset, and color for each effect without duplicating GameObjects.
• One-Click Image Export: Need your UI design for a website or promotional material? Export your customized rectangle directly to a PNG or JPG from the Inspector at various resolution scales (up to 4x).

Workflow Enhancer: Say goodbye to importing endless variations of rounded box images. Keep your project size small and your iteration speed blazing fast!

Stop wasting time creating custom UI sprites in external software!

Better Rectangles is a powerful, highly optimized UI component powered by Signed Distance Fields (SDF). It replaces the standard Unity Image component, allowing you to design beautiful, modern UI elements directly inside the Unity Inspector and Scene View.

Whether you are building sleek menus, customizable cards, or dynamic buttons, Better Rectangles ensures your UI remains pixel-perfect at any screen resolution or scale.