Feed aggregator

Number of textures - 4

Texture dimensions - 4096

Polygon count of Spiked_baton - 5916

Number of meshes/prefabs - 1

Rigging: No

Animation count - No

UV mapping: Yes

LOD information - No

Types of materials and texture maps PBR

Please write any requests for help or suggestions for errors, I will help and fix them as soon as possible.

Low-poly model. Suitable for your projects of genre: RPG, strategy, first person

shooters, etc.

Polycount:

• Vertices - 3319
• Edges - 9195
• Triangles - 5916

Textures:

• 4k PBR Textures (png)
• 1 material
• 4 textures (Albedo, MetallicSmoothness,Normal,AO)

• Plug-and-Play Setup – Works instantly with zero configuration.
• Asynchronous Saving & Loading – Non-blocking operations ensure smooth gameplay.
• Easily Expandable Architecture – Add custom types, slot systems, encryption, or autosave with minimal code.
• Cross-Platform Compatibility – PC, mobile, consoles, and WebGL supported automatically.
• Platform-Aware Save Logic – Automatically adapts behavior for each runtime environment.
• Automatic Component Discovery – Any script implementing ISaveComponent is included.
• Supports Common Unity Types – int, float, bool, string, Vector2/3/4, Quaternion, and more.

Simple Save gives you a system that is:

• Fast
• Powerful
• Reliable
• Future-proof
• Designer-friendly
• Multi-platform
• Extremely easy to use

All in a compact, production-ready package.

Key Features

• 8 Preset Categories - Graphics, Logic, Audio, UI, Managers, World, Lights, Effects with pre-configured colors and icons
• Unlimited Custom Categories - Create your own with custom names, colors, and icon selection
• Visual Icon Picker - Browse and select from 24+ Unity icons with live preview
• Bookmark System - Mark important GameObjects with priority levels (0-10)
• Context Menu Integration - All features accessible via right-click in hierarchy
• Component Icon Display - See which components are attached at a glance
• Prefab Highlighting - Visual indicators for prefab instances
• Group/Ungroup Tools - Organize or flatten GameObject structures quickly
• Collapsible Inspectors - Clean, organized component editors with tooltips
• Debug Logging Toggle - Enable/disable console output on demand
• Assembly Definitions - Proper runtime/editor code separation for fast compilation
• Comprehensive Test Suite - Full PlayMode and EditMode test coverage included
• Non-Destructive Organization - Objects stay as siblings, hierarchy structure preserved
• Persistent Settings - Configuration stored in scriptable object (version control friendly)
• Color Customization - Customize all header and bookmark colors globally
• Add to Existing Categories - Easily add more objects to previously created custom categories

Hierarchy Organizer is the tool I built because I was tired of scrolling through chaotic hierarchies trying to find that one camera or manager buried somewhere. It lets you add visual headers, color-coded categories, and bookmarks right in your hierarchy - no more guessing where things are.

What You Can Do With It

Organize with Visual Headers - Drop in colored category headers (like "━━━ GRAPHICS ━━━" or "━━━ AUDIO ━━━") to section off your hierarchy. Comes with 8 presets (Graphics, Logic, Audio, UI, Managers, World, Lights, Effects), but you can create unlimited custom categories with your own names, colors, and icons.

Bookmark Important Stuff - Mark critical GameObjects so they stand out. Great for things like your main camera, player controller, or that one manager you always need to tweak.

Pick Icons Visually - Forget typing "Camera Icon" and hoping it works. There's an actual icon picker that shows you what's available with live preview.

Quick Actions via Right-Click - Everything's accessible through context menus. Group objects, add categories, bookmark things - all without opening extra windows.

Keep It Clean - Toggle debug logging on when you need it, off when you don't. The console stays quiet unless you're troubleshooting.

Who's This For?

Anyone who works with Unity scenes that have more than 20 GameObjects (so... everyone?). Especially useful if you:

• Work on small teams and need consistent scene organization
• Jump between multiple scenes frequently
• Build complex levels with lots of systems
• Just want your hierarchy to not look all grey

Customization

Everything's tweakable – colors, icons, category names, whatever. The presets are just starting points. You're not locked into any specific workflow or naming convention.

• Full hierarchy serialization
• Local transforms support
• Mesh serialization (vertices, normals, UVs, triangles)
• Skinned and static mesh support
• Reconstruction of hierarchy, transforms, MeshFilter, MeshRenderer
• Applies selected default material
• Render-pipeline independent
• Runtime & Editor support
• Context menu tools for quick export/import
• Works on all major Unity platforms

Model to JSON & JSON to Model is a universal Unity tool that allows you to serialize any 3D model into a JSON file — including full hierarchy, transforms, meshes, materials, and textures — and then reconstruct the model back into the scene with a single click.

This asset is perfect for:

• procedural generation
• networking applications (sending models between client and server)
• modding systems
• saving/loading complex models
• content streaming
• editor tools

⭐ Core Features

🔷 Model → JSON Serialization
Saves:

• full object hierarchy
• local transforms
• Mesh data (vertices, normals, UVs, triangles)
• object active state
• node names

🔷 JSON → Model Reconstruction
Automatically restores:

• object tree
• meshes
• transforms
• active state
• MeshRenderer + MeshFilter
• applies your chosen defaultMaterial

🔷 Render Pipeline Independent
Works with:

• Built-in Render Pipeline
• URP
• HDRP
  You choose which material is applied during reconstruction.

🔷 MeshFilter & SkinnedMeshRenderer Support
Both static and skinned meshes are fully serialized.

🔷 Easy to Use

• context menu options: "Export Full JSON" and "Build From JSON"
• minimal setup
• works in Runtime and Editor

🚀 Why you need this tool

Model to JSON & JSON to Model enables you to:

• transfer 3D models between devices without AssetBundles
• store models in the cloud
• build custom model-editing tools
• generate complex scenes from JSON
• create modular content-storage systems
• export models directly from your game

A lightweight, fast, and fully self-contained solution for working with 3D content through JSON.

📦 Requirements

• Unity 2021.3+ (supports Unity 6)
• Any Render Pipeline
• Android, iOS, Windows, macOS, WebGL support

💡 Support
If you have questions or need assistance, feel free to contact me. Integration help for specific projects is also available.

Auto-generate consistent C# namespaces from folder structure. Perfect for cleaning existing projects. Batch process scripts with custom overrides.

SF Namespace Generator

Ever started a project, added dozens of scripts, then realized you forgot namespaces? This tool fixes that AND automatically adds the missing `using` statements that come with adding namespaces.

What It Does

1. Adds proper namespaces to your scripts based on folder structure
2. Automatically adds missing `using` statements when scripts reference each other
3. Fixes those "type not found" errors that happen after adding namespaces

Key Features

• ✅ Smart Namespace Generation: Creates namespaces from folder paths (Assets/Scripts/UI → YourGame.Scripts.UI)
• ✅ Automatic Using Statements: Detects when ScriptA uses ScriptB and adds `using YourGame.Scripts.UI;`
• ✅ Type Detection: Finds references in generics, attributes, switch cases, and casts
• ✅ Batch Processing: Update hundreds of files at once
• ✅ No Manual Work: One click adds namespaces AND fixes dependencies

Perfect For:

• Projects that grew without namespaces
• Fixing "missing reference" errors after organizing code
• Preparing code for sharing or asset store
• Cleaning up messy codebases

How It Works:

1. Select your project folder
2. Set your root namespace
3. Preview what will change
4. Click apply - gets namespaces AND using statements right

No more manually adding dozens of `using` statements after organizing your code!

Number of textures: 13

Texture dimensions: 4096x4096

Polygon count of [Model Name]

Minimum polygon count: 68416

Maximum polygon count: 68416

Number of meshes/prefabs: 1

Rigging: Yes

Animation count: 26

Animation type list:

UV mapping: Yes

LOD information: N/A

Types of materials and texture maps: PBR

Description

Dragon Worm is a high quality, production ready rigged and animated boss creature for Unreal Engine. It is designed for cinematic reveals, arena encounters and close ups where you need a believable giant wyrm without spending weeks on setup, rigging and animation.

The Dragon Worm uses a custom skeletal rig with a clean bone chain through the whole body, so it deforms smoothly with the included animations and is easy to animate further. The mesh is optimized for real time and keeps a strong, readable silhouette at boss scale.

This pack focuses on encounter-ready animations: burrow in/out, multiple attack variations, strong hit reactions, two posture states (upright and snake/ground), plus grab and throw and a clear death animation for finishing the fight.

Length: approximately 30 meters (3000 cm) - perfect scale for a giant boss encounter.

Included Animations (26)

Attacks and actions:

• DWorm_AttackA
• DWorm_Attack_Left
• DWorm_Attack_Right
• DWorm_Attack_Air
• DWorm_AttackD_AOE
• DWorm_SnakeAttack
• DWorm_GrabNThrow

Burrow:

• DWorm_Burrow_In
• DWorm_Burrow_Out

Reactions and death:

• DWorm_HitReact_Front
• DWorm_HitReact_Back
• DWorm_HitReact_L
• DWorm_HitReact_R
• DWorm_Death

Idles and roars:

• DWorm_IdleA
• DWorm_IdleB
• DWorm_Low_Idle
• DWorm_Low_Idle_In
• DWorm_Low_Idle_Out
• DWorm_SnakeIdle
• DWorm_Roar
• DWorm_SnakeRoar

Crawl variations (animation clips included as movement variations, not a full locomotion system):

• DWorm_Crawl
• DWorm_CrawlSmallAmp
• DWorm_CrawlSmallAmpSnake
• DWorm_CrawlSnake

MODEL DETAILS :

SM_CD

vertices: 1,262

Edges: 3,780Faces 2,520

Triangles: 2,520

SM_hashi

vertices: 232

Edges: 690

Faces 460

Triangles:460

SM_MT

Objects 13

vertices: 54,534

Edges: 161,378

Faces 106,876

Triangles:106,876

SM_CFM

vertices: 61

Edges: 48

Faces: 28

Triangles: 288

TEXTURES DETAILS

textures QTD: 180

Type: PBR (Metallic/Roughness)

Resolution: 4096 x 4096

PBR support: Unity HD render, OpenGL

Skins: 9

Game Ready

Asset Sync: The Essential Workflow Bridge for Professional Unity Teams

Asset Sync is the robust, feature-rich tool that automatically handles the tedious, error-prone task of keeping your source art (from programs like Blender, Maya, Photoshop, etc.) perfectly synchronized with your Unity project.

Key Benefits: Automate Your Workflow, Preserve Your Work

• Seamless Integration: Establish a one-way sync link between any external source folder and a target folder in your Unity project.
• Time-Saving Sync Modes: Choose between fully automatic, real-time syncing for instant updates, or Manual Mode to queue changes for user review and approval.
• Intelligent Material Preservation: Save hours of re-work! When a 3D model is updated, Asset Sync intelligently attempts to preserve any existing material assignments you've made within Unity.

Professional-Grade Control and Review

Asset Sync gives you the precise control and review capabilities demanded by professional studios:

• Visual Diff Tool (Manual Mode): Eliminate guesswork. Before syncing, open a dedicated diff window to visually compare the pending source asset against the current version in your project. Supports textures and 3D models.
• Comprehensive Exclusion System: Keep your project clean and clutter-free.
  Easily manage file and folder exclusions with the intuitive SyncTree Manager, a user-friendly tree view with checkboxes.
  Filter exactly which file extensions (e.g., .fbx, .png, .psd) should be monitored and synced.
  Exclusion rules are persistent across sessions.
• Initial Bulk Sync: Use a dedicated function to perform a fast, one-time, full sync of a large source directory, perfect for initial project setup.

Stay Informed at a Glance

Never wonder about your sync status. Asset Sync provides clear, at-a-glance status indicators via:

• A detailed status box in the main Monitor Window.
• An optional icon in the main Unity toolbar.
• An optional, clickable overlay in the Scene View.

Ready for Any Project

The "Stop Monitoring" cleanup feature provides a clean way to completely decouple the folders and reset your configuration. Built on a foundation of automated tests, Asset Sync is a reliable and stable addition to your development toolkit.

Asset Sync is the 'set it and forget it' solution for integrating external art assets, ensuring your team always works with the latest files without ever breaking existing scene work.

POLYCORE - Low Poly City Life

Create your dream city with this stylized, modular asset pack! Designed specifically for hyper-casual games, city builders, and mobile projects, PolyCore offers a clean and vibrant aesthetic without compromising performance.

All assets are modular and use a shared texture atlas, making them extremely lightweight and optimized for mobile devices.

Key Features

• Modular Workflow: Snap buildings and roads together to create endless city layouts.
• Mobile Ready: Low polygon counts and optimized geometry for high FPS.
• Vibrant Style: Eye-catching colors and clean designs suitable for all audiences.
• Drag & Drop: Prefabs are ready to use with correct pivot points and colliders.

Package Includes

• Buildings: Apartments, Shops, Offices, Hospitals, Restaurants.
• Road System: Straight roads, Corners, T-Intersections, Crossroads (snap-ready).
• Props: Traffic lights, Street lamps, Barriers, Trees, and urban details.
• Demo Scene: A fully assembled sample city to showcase the assets.

Compatibility:

• Works with Built-in Render Pipeline by default.
• Easily upgradable to URP or HDRP using Unity's standard material upgrader.

Features:

• Total Prefabs: 100+
• Texture Dimensions: 128*128, 512x512, 1024x1024, 2048x2048
• Polygon Count: Buildings: 400 - 5000 tris average
• Rigging: No
• Animation: No
• UV Mapping: Yes

## Technical Details

* Full source code included.

* Non-destructive editing workflow.

* Supports any `Texture2D` asset that Unity can import.

* Works with all rendering pipelines (Built-in, URP, HDRP).

* Processing is done via a custom high-performance shader.

* Settings are stored in custom ScriptableObject assets (`.grade.asset`).

* Requires Unity 2020.3 or newer.

Take full control of your texture's appearance directly within the Unity Editor with qs.Texture Grade. 

This extension provides a comprehensive suite of color grading tools that allow artists and developers to fine-tune textures without ever leaving Unity.

Whether you need to tweak the color balance of a single asset or ensure color consistency across your entire project, qs.Texture Grade offers a streamlined, non-destructive workflow that integrates seamlessly into your pipeline.

### Key Features:

* **Non-Destructive Workflow:** Your original textures are always safe. qs.Texture Grade creates a backup of your texture when you start an editing session. You can apply your changes, cancel the session, or revert to the original at any time.

* **Real-time Preview:** See the results of your adjustments instantly. The interactive preview window shows your changes as you make them, allowing for precise control over the final look.

* **Live Histogram:** Analyze the tonal range of your texture with a built-in histogram that updates in real-time. View the combined RGB channels or inspect Red, Green, and Blue channels individually.

* **Levels Control:** Adjust the shadows, mid-tones, and highlights with precision. You can control input/output levels and gamma for Luminosity (all channels) or for R, G, and B channels independently.

* **Professional Color Grading:**

* **Lift, Gamma, Gain:** Use familiar color wheels to adjust the dark, mid, and bright tones of your image.

* **HSL & Contrast:** Fine-tune the Hue, Saturation, and Lightness of your texture, and adjust the overall contrast.

* **Advanced Curve Editor:** Get ultimate control with a full curve editor. Adjust the master curve or manipulate the Red, Green, and Blue channels individually for precise color correction.

* **Seamless Integration:**

* Access the tool from the `Assets` context menu for any `Texture2D` or from the `Tools/qs.TextureGrade` menu.

* Settings are saved in a convenient `.grade.asset` file right next to your texture, making it easy to manage and version control.

**qs.Texture Grade** is the perfect tool for any Unity developer looking to enhance their visuals and streamline their texture workflow.

Technical Details

• Total Prefabs: 20 (5 Elements x 4 Types)
• Texture Resolution: 512 x 512 px
• Texture Type: Base Color, Alpha, Emission
• Shader Type: Particle Standard (Mobile compatible) / Shader Graph (for URP/HDRP)
• Polygon Count: Approximately 240 - 360 triangles per mesh-based effect.
• Supported Render Pipelines: Standard (Built-in) Universal Render Pipeline (URP) High Definition Render Pipeline (HDRP)
• Mobile Ready: Yes (Highly optimized for low-end to high-end mobile devices)
• Requirements: Unity 2022.3.62f2 or higher.

Sasual EffectVFX Pack is a lightweight and versatile elemental VFX pack specifically optimized for mobile platforms. It features 5 essential elemental properties—Fire, Water, Grass, Poison, and Dark—each designed to provide high-quality visual feedback without compromising performance.

With 20 pre-configured prefabs, this package covers all the fundamental combat effects needed for an RPG or Action game. Each element includes four distinct types of effects: Hit, Sword Slash, Aerial Explosion, and Ground Explosion. These are designed to be "plug-and-play," allowing you to enhance your game's combat feel instantly.

Key Features:

• 5 Elemental Themes: Fire, Water, Grass, Poison, and Dark.
• 4 Combat Essentials per Element: Hit, Sword, Aerial Explosion, and Ground Explosion.
• Mobile Optimized: Designed with low-draw calls and efficient texture usage for smooth performance on mobile devices.
• Cross-Pipeline Compatibility: Full support for Built-in, URP, and HDRP.

Number of textures: 13

Texture dimensions: 4k and 1k

glass 1024*1024

other textures 4096*4096

Polygon count of [Western barn]

• tris 10022
• verts 11333

fence

• tris 310
• verts 425

Number of meshes/prefabs: 3

Rigging: No

UV mapping: Yes

Western barn and fence 3d models

Barn

• tris 10022
• verts 11333

Fence

• tris 310
• verts 425

Asset Overview

• 26 modular structural pieces
• 85 environment & gameplay props
• 111 total unique assets

Polygon Count

• Small props: 40-600 tris

• Medium props: 1000-2500 tris

• Large props: 3000-8000 tris

• Wall modules: 600-2000 total tris

Polygon counts are approximate and may vary slightly per asset.

Texture resolutions:

• 256×256

• Base color map (Single shared texture atlas)

Lighting-Ready Assets

• All models include clean secondary UVs (UV2) for lightmaps, tested for baked lighting without visible seams
• Only one main atlas is used for all objects - consistent lighting and improved batching
• Smooth shading with carefully placed hard edges for perfect stylized normals
• Lightmap UVs have correct padding to avoid bleeding or artifacts
• A fully baked demo scene is included to show results

Technical

• All meshes are proper low poly (not subdivided, clean topology)
• Models use ideal pivot placement for easy snapping, modular alignment, functional doors and chests
• Consistent scale across all assets
• Optimized for performance in real-time engines

Extra Effects

• Fire particles included (torches & candles)
• Ready-to-use prefabs

This pack includes a complete set of modular structures, over 85 detailed props, optimized lighting-ready meshes and a fully baked demo scene to showcase the quality of the environment.

All models use a clean, polished low-poly style, ideal for RPGs, dungeon crawlers, roguelikes and any fantasy setting.

Every asset is optimized for performance, with correct pivots, unified atlas-based texturing, and high-quality secondary UVs for flawless lightmap baking.

• Format: WAV (48k Hz / 16-bit)
• Loopable: No
• Total Track Length: 1 hour, 31 minutes, 13 seconds.
• Total Files: 21 music tracks
• Additional: Stereo

Description

Mystic Eastern Horizons – Oriental Fantasy Music Pack is perfect for RPG, open-world, MMORPG, adventure, strategy, cinematic scenes, and any project that requires a rich Eastern/Asian fantasy atmosphere.

Bring life, culture, and soul to your world with a soundtrack crafted for exploration, storytelling, and unforgettable moments.

Key Features

• 20+1 high-quality music tracks (.WAV)
• 5 thematic regions, each with 4* unique tracks. (*1 bonus)
• Suitable for RPG, JRPG, MMORPG, open-world, strategy, casual, and mobile games

Designed for exploration, combat, village themes, spiritual areas, temples, dungeons, and cinematic storytelling

Track List (20+1 Total)

Sakura Province (Peaceful / Social / Village Themes)

1. Blossom Breeze

2. Lanterns Over the River

3. Cherry Pathway

4. Gentle Steps of the Village

Jade Peaks (Mountains / Exploration / Nature)

5. Whispering Cliffs

6. Path of Emerald Winds

7. Summit of Silent Snow

8. Spirit of the High Pass

Moonlit Forest (Mystic / Fantasy / Spiritual)

9. Echoes of the Moon Shrine

10. Spirits Beneath the Leaves

11. Celestial Fireflies

12. Forest of Ancient Whispers

Dragon Empire (Combat / Adventure / Tension)

13. March of the Crimson Dragon

14. Clash at the Emperor’s Gate

15. Blades of the Rising Sun

16. Fury of the Golden Sentinel

17. Heroes of Warzone

Temple of Ages (Sacred / Ambient / Mystery)

18. Prayers of the Old Stone

19. Chamber of Eternal Echoes

20. Enlightened Steps

21. Guardians of the Inner Sanctum

• Tracks 20+ 3D hand landmarks per hand (wrist, MCP, PIP, DIP, fingertips)
• Independent left/right hand detection
• Real-time 3D pose output for rigged hand mesh animation
• Three modes: Landmark Tracking, Mesh Tracking, Mesh Tracking & Movement
• Input sources: Camera, Video, Image
• Heavy and Lite models (Lite recommended for mobile)
• Works with custom Generic-rig hand models
• Adjustable camera selection and resolution
• Includes prefabs and demo scenes for quick integration

Plugin Type: HandMesh Tracking
Supported Unity Versions: Unity 2021.3 or later
Supported Platforms: Android, iOS, Windows, macOS, Linux
Architecture: ARMv7, ARM64, x86_64

HandMeshTracking – Real-Time 3D Hand Tracking & Mesh Animation for Unity

HandMeshTracking is a powerful, easy-to-integrate Unity plugin that brings real-time 3D hand tracking, gesture-based interaction, and fully animated hand meshes directly into your projects. Whether you're building AR apps, VR experiences, or hand-controlled games, this plugin provides a complete solution for natural, intuitive hand interaction.

Powered by advanced machine learning, HandMeshTracking can detect left and right hands, track 20+ 3D landmarks per hand, and accurately animate finger joints, wrist rotation, and full hand poses. With support for camera, video, and image input sources, plus mobile-optimized models, you get both performance and precision in any environment.

Simply drag the included prefab into your scene, assign your hand model, and your project is instantly ready for real-time hand interaction.

Key Features

• Real-Time 3D Hand Tracking
Tracks 20+ hand landmarks, including fingertips, knuckles, and wrist, with high accuracy and stable motion output.

• Full Hand Mesh Animation
Automatically animates hand models using real hand movements, including finger curl, spread, rotation, and pose transitions.

• Left & Right Hand Detection
Independently detect and process each hand for more accurate interaction logic.

• Hand Mesh Movement Support
Follow the user’s hand position and scale in world space for natural, immersive interaction.

• Multiple Input Sources
Use live camera feed, video files, or images as tracking input.

• Performance-Optimized Models
Choose between Heavy (high accuracy) and Lite (mobile optimized) tracking models.

• Simple Integration
Ready-made prefabs and scripts allow setup in minutes—no complex configuration required.

• Included Demo Scenes
Examples for landmark tracking, mesh animation, and mesh movement help you understand and extend the system quickly.

Perfect For

• AR and VR hand interaction
• Gesture-controlled games
• Virtual object grabbing, touching, and UI interactions
• Mixed Reality applications
• Robotics, training, and research projects
• Any experience requiring natural hand input

• Unity Version: 2020.3 LTS or newer

• Input Support: Unity Legacy Input System and New Input System

• Physics: Rigidbody-based character movement

• Animation: Code-driven procedural animation

• Camera: First-person and third-person modes with smooth interpolation

• Environment Detection: Layer- and collider-based sensors

• AI: NavMesh-based pathfinding (requires baked NavMesh)

• Audio: 3D spatial audio with logarithmic rolloff

• Rendering Pipeline: Built-in Render Pipeline (URP/HDRP compatible with material swaps)

• Intended Use: Single-player, client-authoritative gameplay

VoxelPlayerController is a complete, architecturally-driven character controller system for 3D Unity projects. It is not just a movement script, but a fully modular ecosystem built on a strict Separation of Concerns philosophy, allowing each system to operate independently.

The asset includes a Rigidbody-based player controller with multiple locomotion states (Idle, Walk, Run, Crouch, Jump, Dash), automatic sprinting, slope handling, stair traversal, and robust fall detection. A full swimming system provides buoyancy-based movement, smooth land/water transitions, and camera-relative controls.

Input is handled through a unified abstraction layer supporting both Unity’s Legacy Input System and the New Input System. The dynamic camera system supports first-person and third-person modes with smooth interpolation, collision avoidance, and water adaptation.

The package also includes a modular melee combat system with weapon inventory, equip/unequip animations, configurable attack arcs, and sphere-cast hit detection. Enemy behavior is handled by the AdvancedNPC system, featuring state-driven AI with NavMesh navigation, patrol, chase, attack, return, and death states.

Additional systems include a centralized audio controller with dedicated AudioSource domains, an event-driven health system with fall damage, death and respawn logic, visual feedback via a lightweight effect system, and runtime debugging tools. The entire system is designed to be plug-and-play, highly configurable through the Unity Inspector, and suitable for professional production environments.

Features

• Runtime plane-based splitting (single or multi-plane)
• Reliable cap triangulation: fan (convex), ear-clipping (concave), CDT (holes)
• Planar UVs for caps to a selectable UV channel; sides keep UV0
• Two submeshes (sides / caps) to assign a dedicated cap material
• Optional convex MeshCollider generation and Rigidbody inheritance
• Recursive fragmentation: None, All, Depth, Volume
• Pooling + scratch buffers to reduce allocations and spikes
• Simple API: ApplyImpact(...) and ApplyImpactWithPlanes(...)
• Fast path skips island detection when a single loop is produced

API notes

• ApplyImpact(point, impactPower, out fragments, optionalDirection)
  Uses breakingThreshold and useAccumulation with the impactPower you pass to decide if a split occurs. If it proceeds, it generates splitPlaneNumber planes (optionally aligned by optionalDirection).
• ApplyImpactWithPlanes(planes, out fragments)
  Always splits using your planes; ignores breakingThreshold, useAccumulation, and splitPlaneNumber.
• If reactToCollision is enabled, impact power is derived from Unity’s relativeVelocity × collisionMultiplier, compared against breakingThreshold (respecting useAccumulation).

Included

• Scripts :
  Destructible (runtime plane-based splitter), FragmentPool, DestructibleDemoController
  Editor: DestructibleEditor
  Triangulation (standalone usable): Geometry.Triangulation/EarClipping.cs, CDT.cs
• Documentation :
  PDF manual: Destructible_BSP_Splitter_Manual.pdf (offline, step-by-step + API notes)
• Demo content :
  Test meshes for triangulation cases (convex, concave, holes)
  Matching materials and textures for those meshes
  Simple demo scene showcasing projectile + hitscan usage
• Namespaces :
  Destruction and Geometry.Triangulation

Requirements

• Unity 2022.3+ (Unity 6 supported)
• Meshes must be Read/Write Enabled
• Works with Built-in, URP, HDRP (renderer-agnostic)

Performance

• Reuses internal buffers; GC kept low
• Most cuts yield a single intersection loop (fast path)
• Optional colliders/rigidbodies add runtime cost proportional to fragment count

Limitations & notes

• LODGroup: recommend forcing LOD0 before splitting; avoid reactToCollision on LOD’d objects
• Cap shading: for PBR, caps may look glossier if smoothness/metallic maps don’t match planar UVs; assign a dedicated cap material or author cap textures
• Physics: fresh convex colliders may slightly inflate; dense fragments can initially overlap and depenetrate strongly

Licensing/usage

• No external dependencies. Code is namespaced (Destruction, Geometry.Triangulation).

The Destructible Component is a lightweight, runtime mesh splitter that fractures any Read/Write mesh along one or more planes. It generates clean caps with planar UVs (to a channel you choose), separates sides/caps into two submeshes for easy styling, and optionally adds convex colliders and rigidbodies with velocity/mass inheritance.
It’s renderer-agnostic (Built-in/URP/HDRP), uses pooled scratch buffers to minimize GC, and supports recursive fragmentation by depth or minimum volume. Triangulation adapts per case: fan for convex caps, ear-clipping for concave, and CDT when holes/constraints are present.
Great for action, sim, and VFX—any project that needs convincing, controllable destruction without heavy authoring.

Render Pipeline Compatibility:
✔ Built-in
✔ URP
✔ HDRP

Texture Type: HDRI / Skybox
Resolution: 16384 × 8192 (16K)
Bit Depth: 32-bit float
Color Space: Linear
Projection: Equirectangular (2:1)
Seamless: Yes
Formats: .EXR, .HDR (only 6 out of 8 skyboxes come in EXR format, due to extreme large project files)
Compression: Lossless
Texture Count: 8
LOD: Not applicable
VR Ready: Yes
Mobile: Not recommended (16K resolution)
AI Generated: No
Upscaled: No

HDRI 16K Cosmos is a premium collection of ultra-high-resolution space and cosmic panoramas, rendered natively at true 16K (16384×8192) in full 32-bit floating-point dynamic range.

These HDRIs are NOT AI-generated and NOT upscaled.

Each panorama is physically rendered at native resolution, ensuring maximum sharpness, clean star fields, smooth nebula gradients, accurate light intensity, and artifact-free reflections.

Perfect for:
• Unity HDRP & URP skyboxes
• Image-Based Lighting (IBL)
• Reflections and environment probes
• Sci-Fi and space games
• Cinematic lighting and cutscenes
• VFX and compositing
• VR and 360° environments
• Virtual production
• Space and nebula backgrounds

Pack Contents

• 8 ultra-detailed space & nebula HDRIs
• Native Resolution: 16K (16384 × 8192)
• Bit Depth: 32-bit float
• Projection: Equirectangular (2:1)
• Seamless: Yes (no seams, no poles)
• Formats: EXR and HDR (only 6 out of 8 skyboxes come in EXR format, due to extreme large project files)
• True dynamic range for physically based lighting
• Clean gradients, no banding, no denoising artifacts

Technical Quality

• True native 16K renders (not upscaled)
• Physically accurate star and nebula luminance
• High-precision reflections for metallic materials
• Suitable for real-time and offline rendering
• No AI artifacts, no synthetic noise, no fake detail

Designed for professional lighting, skybox rendering, and cinematic space environments in Unity.

--- Customers Using Full Version---

StupidMonkeys

Big Heart

GospelGo

StudyCheetah.App

Preview

🤔Why this system?

• Responsive & Fullscreen – Adapts to all screen sizes
• Cross-Platform - Windows, macOS, Linux, ChromeOS, iOS*, Android
• Easy To Use - User friendly and customizable with an in-depth wiki

☝️For what?

• Game jams: Compatible with itch.io
• Pitching & Portfolios: Send publishers/investors a link to launch instantly.
• Zero-friction: Share a single link, instant access, no Steam keys

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

👀 FEATURES 👀

🛠️ Compatibility & Performance

• Supports Unity 2020.1 & Newer
• Responsive – Landscape & Portrait Modes
• Works with any OS as long as the browser supports WebGL
• Windows, macOS, Linux, ChromeOS, iOS*, Android and more
• Browsers tested: Chrome, Firefox, Edge, Safari, Opera
• Supports WebGPU (WebGL2 Successor) [Requires Unity 6.1+]

📱 Display & UI

• Display Options:
• Automatic Letterboxing / Pillarboxing
• Dynamic Aspect Ratio
• Free Aspect
• Fixed Resolution
• Custom background images for loading screen
• Show your game/company logo while loading
• Uses Google Fonts

🎮 Player Experience

• Prevent save-menu popups (Ctrl+S block)
• Prevent tab close (Ctrl+W block)
• Disable Fullscreen Button

🧰 Development Tools

• 40+ customizable settings
• Save presets & reuse across projects
• Unbeatable support

Get The Full Version Here:

https://assetstore.unity.com/packages/tools/integration/lively-webgl-template-314596

  Requirements

  | Requirement | Details |

  |-------------------|-----------------------------------|

  | Unity Version | 2021.3 LTS or newer |

  | Unity 6 | Fully compatible |

  | Scripting Backend | Mono and IL2CPP |

  | API Compatibility | .NET Standard 2.1, .NET Framework |

  | Dependencies | None |

  Render Pipeline Support

  | Pipeline | Status |

  |----------------------------------------|-------------------|

  | Built-in Render Pipeline | ✅ Fully Supported |

  | Universal Render Pipeline (URP) | ✅ Fully Supported |

  | High Definition Render Pipeline (HDRP) | ✅ Fully Supported |

  | Custom SRP | ✅ Fully Supported |

  This is an editor-only tool. No shaders, no materials, no rendering code. Uses Unity's built-in EditorGUI

  exclusively.

  Platform Support

  Works on all platforms Unity supports. The tool runs entirely in the Editor and is automatically stripped from

  builds.

  | Platform | Status |

  |----------|--------|

  | Windows | ✅ |

  | macOS | ✅ |

  | Linux | ✅ |

  Performance

  | Aspect | Details |

  |-------------------|-----------------------------------------|

  | Runtime Overhead | Zero - editor-only |

  | Build Size Impact | None - automatically excluded |

  | Inspector Repaint | Minimal overhead with efficient caching |

  | Memory Usage | Lightweight, cached lookups |

  Package Contents

  | Folder | Contents |

  |-----------|------------------------------------------------------|

  | Editor/ | All editor scripts, drawers, windows, and inspectors |

  | Runtime/ | Attribute definitions and serializable types |

  | Examples/ | Demo scripts showcasing all features |

  | Tests/ | 40+ automated NUnit editor tests |

  File Count

  | Type | Count |

  |----------------------|-------------------------------------|

  | C# Scripts | ~40 |

  | Assembly Definitions | 3 |

  | Documentation Files | 3 (README, CHANGELOG, package.json) |

  | Example Scripts | 6 |

  | Automated Tests | 40+ |

  Assembly Definitions

  | Assembly | Platform | Purpose |

  |-------------------------------|---------------|-----------------------------------|

  | InspectorProLite.Editor | Editor only | Core editor functionality |

  | InspectorProLite.Runtime | All platforms | Attributes and serializable types |

  | InspectorProLite.Tests.Editor | Editor only | Automated tests |

  Code Architecture

  - Namespace: InspectorProLite

  - No global namespace pollution

  - Clean separation between editor and runtime code

  - Extensible base classes for custom editors

  - ScriptableObject-based settings with Project Settings integration

  Settings Storage

  | Setting Type | Storage Location |

  |------------------------|-----------------------------|

  | Project Settings | ScriptableObject in project |

  | Favorites | EditorPrefs (per-user) |

  | Foldout States | EditorPrefs (per-user) |

  | Component Notes | EditorPrefs (per-user) |

  | Custom Color Overrides | EditorPrefs (per-user) |

  Keyboard Shortcuts

  | Shortcut | Action |

  |--------------|------------------------|

  | Ctrl+Shift+I | Open Quick Settings |

  | Ctrl+Shift+F | Open Component Search |

  | Ctrl+Alt+A | Open Quick Add Palette |

  Integration

  | Feature | Details |

  |------------------------|----------------------------------------------------------------|

  | Custom Editors | Extend InspectorProLiteBaseEditor for automatic header support |

  | Custom PropertyDrawers | Full compatibility |

  | Odin Inspector | Compatible (can run alongside) |

  | Other Inspector Tools | Non-conflicting |

  Tested Unity Versions

  | Version | Status |

  |------------|----------|

  | 2021.3 LTS | ✅ Tested |

  | 2022.3 LTS | ✅ Tested |

  | 2023.x | ✅ Tested |

  | Unity 6 | ✅ Tested |

  Support

  - Full documentation included

  - Example scripts demonstrating all features

  - Automated test suite for verification

  - Contact publisher through Asset Store for questions

  Inspector Pro Lite

  Inspector Pro Lite transforms Unity's default Inspector into a powerful, organized workspace. Whether you're

  building games, apps, VR experiences, or simulations, this tool helps you work faster and stay organized.

  Visual Organization

  Color-Coded Component Headers

  Instantly identify component types at a glance. Physics components (Rigidbody, Colliders, Joints) appear in blue.

  Rendering components (MeshRenderer, Light, Camera) in green. Audio in orange. UI in pink. Animation in yellow.

  Custom scripts in gray. No more scrolling through walls of identical-looking components.

  Enhanced Separators

  Beautiful 3D gradient headers with shadow effects replace Unity's flat component headers. Each component stands

  out with its category color, making complex GameObjects with many components easy to navigate.

  Custom Color Rules

  Define your own coloring system. Match components by:

  - Contains - "Controller" matches PlayerController, EnemyController, etc.

  - StartsWith - "UI" matches UIManager, UIButton, etc.

  - EndsWith - "Manager" matches GameManager, AudioManager, etc.

  - Exact - Match specific component names

  - Namespace - Color entire namespaces (great for third-party assets)

  Productivity Tools

  Component Favorites

  Star frequently-used components with one click. Access your favorites from a dedicated window and add them to any

  GameObject instantly. Perfect for components you use repeatedly like Rigidbody, AudioSource, or your custom

  scripts.

  Component Search

  Find any component or property instantly with Ctrl+Shift+F. Search by component name, property name, or browse by

  category. Click to ping or add components directly from search results.

  Quick Add Palette

  Press Ctrl+Alt+A to open a fast component palette. Your favorites appear at the top, followed by recently-used

  components. Search any component type and add it with one click. Much faster than navigating Unity's Add Component

   menu.

  Component Presets

  Save component configurations and apply them to other objects. Set up your perfect Rigidbody settings once, save

  as preset, and apply to any Rigidbody in your project. Great for maintaining consistency across your game.

  Component Notes

  Add comments directly to components. Document why settings are configured a certain way, leave reminders for

  yourself, or communicate with team members. Notes appear right below the component header.

  Inspector Attributes

  Enhance your custom scripts with powerful attributes:

  Visual Attributes

  - [ColorHeader] - Add colored section headers

  - [Separator] - Draw colored divider lines

  - [InfoBox] - Display info, warning, or error messages

  - [Highlight] - Color field backgrounds for emphasis

  Organization Attributes

  - [InspectorGroup] - Collapsible, colored property groups with smooth animation

  - [Tab] - Organize properties into tabbed views

  - [ReadOnly] - Display non-editable fields

  Conditional Attributes

  - [ShowIf] / [HideIf] - Show or hide fields based on conditions

  - [EnableIf] / [DisableIf] - Enable or disable fields conditionally

  - [ShowIfMultiple] - AND/OR logic with multiple conditions

  - [ShowIfComparison] - Compare numeric values (greater than, less than, equals)

  Validation Attributes

  - [Required] - Mark fields that must have a value

  - [ValidateRange] - Ensure values stay within bounds

  Input Attributes

  - [Password] - Masked input with visibility toggle

  - [ProgressBar] - Display values as colored progress bars

  - [MinMaxSlider] - Range selection with dual handles

  - [ResizableTextArea] - Text areas that can be resized

  - [SearchableEnum] - Search through large enums easily

  Dropdown Attributes

  - [SceneDropdown] - Select from build scenes

  - [TagDropdown] - Select from project tags

  - [LayerDropdown] - Select from project layers

  - [Dropdown] - Custom dropdown options

  Button Attributes

  - [Button] - Clickable buttons that call methods

  - [ConfirmButton] - Buttons with confirmation dialogs

  - [ConditionalButton] - Buttons that enable/disable based on conditions

  - [ButtonGroup] - Horizontal button groups

  - [PlayModeButton] / [EditModeButton] - Mode-specific buttons

  Special Features

  - [InlineEditor] - Edit ScriptableObjects directly in the inspector

  - [AssetPreview] - Show asset thumbnails

  - [CurvePreview] - Enhanced AnimationCurve editing with presets

  - [GradientPreview] - Enhanced Gradient editing with presets

  - [FindReferences] - Button to find all references to an asset

  - [SceneReference] - Warns about cross-scene references

  - [EnhancedList] - Lists with pagination, search, and reordering

  - [SerializableDictionary] - Full dictionary support in the inspector

  Additional Tools

  Mesh Analyzer

  Automatically displays mesh statistics on MeshFilter components: vertex count, triangle count, submesh count,

  bounds, and size in multiple units. Toggle between meters, centimeters, feet, inches, or define custom units.

  Quick Settings Window

  Access all features from Tools > Inspector Pro Lite > Quick Settings or Ctrl+Shift+I. Toggle features on/off

  instantly with visual feedback. One-click access to full settings.

  Project Settings Integration

  All settings accessible from Edit > Project Settings > Inspector Pro Lite. Configure colors, enable/disable

  features, manage custom rules, and import/export settings as JSON for team sharing.

  Customization

  Everything is customizable:

  - Category colors for each component type

  - Color intensity and opacity

  - Gradient headers on/off

  - Enhanced separators on/off

  - Individual feature toggles

  - Custom color rules

  - Mesh analyzer units

  - Keyboard shortcuts

  Who Is This For?

  Solo Developers

  Stay organized as your project grows. Find components faster, save time with presets, and keep documentation right

   in the Inspector.

  Teams

  Share settings via JSON export. Use component notes for communication. Maintain consistency with presets.

  Color-code by namespace to identify different team members' code.

  Asset Developers

  Make your assets more professional with organized inspectors. Use groups, tabs, and validation to create polished

  editor experiences.

  Anyone Working on Complex Projects

  The more components you have, the more time Inspector Pro Lite saves. Stop scrolling, start finding.

  Compatibility

  - Unity Versions: 2021.3 LTS and newer, Unity 6 ready

  - Render Pipelines: Built-in, URP, HDRP, and custom SRPs

  - Platforms: All platforms (editor-only tool)

  - Custom Inspectors: Works alongside your existing custom editors

  - Third-Party Assets: Compatible with other inspector tools

  Performance

  - Editor-only - zero runtime overhead

  - Automatically stripped from builds

  - Efficient color caching

  - Minimal Inspector repaint cost

  ---

  Inspector Pro Lite works with any project type, any genre, and any workflow. It's a quality-of-life improvement

  for every Unity developer.