Asset Store newest packages

- 5 free mesh editing tools

- Single object workflow with Use Selection button

- Professional dark theme UI

- Performance Assistant (scan only)

- Compatible with Standard, URP and HDRP

- Unity 2020.3+ supported

- Editor-only package (no runtime overhead)

- Full version available: Mesh Dominus Pro

Mesh Dominus Lite is a free demo version of Mesh Dominus Pro — a professional all-in-one mesh toolkit for Unity.

⚙️ INCLUDED TOOLS:

- Pivot Editor — Set pivot to Center, Bottom Center or Top Center

- Mesh Combiner — Combine child meshes into one static mesh (reduces draw calls)

- Mesh Separator — Separate combined mesh by submesh or material

- Freeze Transform — Bake transform values into mesh vertices

- Mesh Cleaner — Scan project for unused mesh assets

This lite version gives you a taste of what Mesh Dominus Pro offers. Purchase the full package to unlock all 14

professional mesh tools including Mesh Simplifier, Mesh Optimizer, Auto LOD Generator, Mesh Smoother, Double Side

Tool, Mesh Extractor, Material Atlas Generator, Auto Collider Generator & Mesh/SkinnedMesh Converter.

👉 Get Mesh Dominus Pro (Full Package):

This asset was designed for the 2D URP pipeline. It also works in 3D projects, but the refraction setup will not be available. To use refraction, a 2D URP project is required.

You can customize:

• Water waves (speed and amplitude)
• Refraction (noise, scale, and speed)
• Foam (color, position, noise scale, and amount)
• Color (top color, bottom color, opacity, and gradient)
• Transparency
• Texture
• Alpha clipping

Just apply this material to any 2D sprite and it will work.

NOTE: To enable refraction, you only need to complete a one-minute setup in your 2D URP asset. Detailed instructions are included in the PDF file that comes with this asset.

A 2D water material that is easy to set up. Just apply it to a square sprite and start customizing it to fit your project needs.

With this material, you can add refraction, waves (frequency, speed, and amplitude), color, foam, depth color from bottom to top, noise, transparency, and masking if needed. It is perfect for 2D projects and highly optimized for performance.

NOTE: This shader is only compatible with 2D URP.

• 3 original high-quality WAV tracks (48khz kHz / 24-bit)
• 07:55 of unique music
• 135 MB of music
• Unlimited Royalty-Free license
• Free Updates Forever

Audio Previews

Description

You need a unique sound. Something…different. Crazy Classical Game Music steps up to give you a one of a kind sound that will only work for the right game. This collection brings an insanely zany, creative, mold-breaking sound to your game. It sounds like a

• Madcap Classical Frenzy
• Classical Gone Feral
• Ransacked Symphony
• Chaotic Chamber Music Played By Humans and Monsters/Orcs/Goblins/Creatures

This first iteration of Crazy Classical Game Music is 3 hand-crafted tracks like no other using only the most famous and recognizable classical music.

1. Vivaldi’s Four Seasons: Spring
2. Beethoven’s 5th Symphony
3. Bach’s Cello Solo In D Major No. 1

========================

100% YouTube Safe Forever

========================

I will never, now or in the future make any claim on Youtube to take the monetization from your content that uses this audio.

Add Crazy Classical Game Music to your cart and buy now!

===============================

FILE-NAMING & FOLDER STRUCTURE:

===============================

BPM (beats per minute) added to every track filename: now you know exactly how fast every track will be before previewing, saving a ton of time when searching for your next track.

Keys: Every track has the key baked into the name so you always know exactly what you are going to get.

NEW TRACKS: As I add more tracks in the future, they will be included at no additional cost to you. These updates are always free!

Add Crazy Classical Game Music to your cart and buy now!

==================

About The Composer

==================

Hi! I’m Dan thanks for taking the time to check out my wild and mad-cap music! I am available to compose custom music for your game right now!

Send me an email here so we can talk about creating amazing custom music for your game: support@bestmusiccoach.com

My website: https://www.musicmentordan.com/projects?htrafficsource=unity&el=crazy-classical

Technical Details

Seamless Editor Integration

The tool is designed to feel like a native part of your Unity workspace, prioritizing practical accessibility and a frictionless workflow before relying on its heavier backend optimizations.

• Tabbed Workspace & Quick Ingestion: Manage multiple staging queues simultaneously using the persistent tabbed interface. Getting files into the tool is instantaneous: you can drag and drop entire folders or individual .cs scripts directly into the window, or simply highlight assets in your Project view and use the right-click context menu to instantly append them to your active workspace.
• Minimal Project Footprint: The asset is incredibly lightweight, consisting entirely of a handful of Editor scripts. It resides completely within its own isolated Assembly Definition (.asmdef) and custom namespace. It has strictly zero external dependencies and requires no initial setup.
• Zero Resource Drain & Safe Removal: The tool is engineered to sit quietly in your project. It consumes absolutely zero CPU or memory resources when the window is closed, and maintains a highly optimized, minimal footprint when open. Because it is strictly an Editor-only tool, it is completely excluded from your runtime builds. If you ever decide you no longer need it, simply delete the asset folder—it leaves no trace, dangling scripts, or broken references behind.
• Non-Destructive & Persistent: The exporter acts strictly as a read-only formatting engine. It loads files into memory to build the final payload and will never overwrite, truncate, or modify your actual source code on disk. Furthermore, native Unity UI state serialization ensures your active queues and scratchpad drafts safely survive script recompilations (Domain Reloads) without wiping your staged work.
• Safe Regex Comment Stripping: Comment removal utilizes a compiled Regular Expression engine meticulously designed to identify and preserve string literals ("...", $"...", @"{...}") before searching for comments. This ensures that // or /* characters found inside URLs or debug messages are never accidentally stripped.
• Assembly Caching & Path Normalization: To prevent Editor freezes during mass drag-and-drop operations, the tool bypasses standard string comparisons by building a lazy-loaded, instantly accessible cache of your project's assemblies. It also sanitizes all ingestion paths, automatically resolving Mac and Windows slash discrepancies so native compilation API lookups function flawlessly. This cache automatically flushes and updates the moment your project hierarchy changes.

Technical Specifications

• Namespace: Veridian.ContextBundler.Editor
• Assembly: Veridian.ContextBundler.Editor.asmdef
• Environment: Unity Editor Only (Safely stripped from all runtime builds).
• Output Formats: Generates output directly to the system clipboard, or saves to local disk as Markdown (.md) or Plain Text (.txt).
• Dependencies: None. This tool utilizes standard internal Unity Editor APIs and requires no external packages or libraries.

The CleanScript Exporter is a time-saving Unity Editor utility designed to instantly collate and export C# scripts without the friction of opening an external IDE. Opening multiple scripts in standard code editors just to copy their contents is a tedious, time-consuming bottleneck. This tool bypasses that entirely, allowing developers to drag and drop entire folders or specific files directly into a Unity window for immediate clipboard access. While its primary function is rapid, IDE-less text extraction, it is augmented with powerful optimization features—including comment stripping and dependency mapping—to output clean, bounded text payloads.

Note: Once imported, this tool operates under its internal engineering name which is "Context Bundler". Access it via the top menu: Tools > Veridian > Context Bundler. .

Core Workflow & Interface

• Instant Staged Queue: Drag and drop folders or individual .cs files directly into the window. The tool recursively searches directories and populates a staging queue, keeping updated versions of your scripts ready to be copied instantly.
• IDE-Free Extraction: Select entire modules and instantly copy the combined C# logic directly to your clipboard or local drive, completely bypassing external editor load times.
• Safe Comment Stripping: A custom Regex-driven engine allows you to globally or individually strip legacy inline (//) and block (/* */) comments to reduce the overall text footprint. An optional setting intelligently preserves structural C# XML documentation (///).
• Custom Instruction Preamble: Prepend high-level directives to the top of your exported file using a version-controlled InstructionPresetLibrary (ScriptableObject) to save, share, and inject standardized export instructions.
• Architecture & Dependency Mapping: The tool natively reads Unity's CompilationPipeline data to generate a Markdown-formatted map of all staged assemblies (.asmdef) and their explicit one-way dependencies.

Primary Use Cases

1. Collaboration & Asynchronous Peer Review

When collaborating with external contractors or conducting peer code reviews, sending an entire multi-gigabyte Unity project repository is impractical. The CleanScript Exporter allows lead engineers to grab a specific feature module, strip redundant legacy comments, and instantly output a single, clean .md file. This provides the reviewer with the exact, bounded context they need without exposing the proprietary codebase or forcing anyone to manually aggregate files.

2. Rapid LLM Context Preparation

For developers utilizing Large Language Models (LLMs) for code analysis, refactoring, or generation, gathering context is often a frustrating process. Opening five different scripts in an IDE simply to copy and paste their text wastes valuable time. The CleanScript Exporter solves this by acting as an instantaneous context-window engine directly inside Unity.

• Frictionless Copying: Drag a feature folder into the tool and instantly copy the codebase to your clipboard in a single click, keeping your workflow fast and uninterrupted.
• Token Footprint Optimization: By utilizing the comment stripper and preserving only structural XML, developers significantly reduce the character footprint of their payload, saving valuable token bandwidth for the actual API response.
• System Prompt Injection: The Instruction Library acts as a centralized repository for system prompts, ensuring consistent LLM constraints across the studio without having to retype them.
• Preventing Architectural Hallucinations: By prepending the Architecture & Dependency Map, the LLM reads the one-way dependency flow of your architecture first. It is explicitly instructed to adhere to these boundaries, effectively constraining the model from generating code that assumes access to isolated namespaces or creates circular dependencies.

3. Project Documentation

The tool serves as a rapid generator for internal technical documentation, allowing teams to instantly bundle module logic and structural boundaries into text formats suitable for Git wikis or internal knowledge bases.

Package Expectations

• Editor-Only: This is strictly an Editor utility and will not affect or bloat runtime application builds.
• No Demo Scene or Artwork: This package contains only the functional Editor window and background compilation scripts. It does not include demo scenes, 3D models, or artwork.

More from Veridian:

If you find this tool useful, please consider browsing our publisher page for additional free assets, or reviewing our premium optimization suite below.

BurstLOD: Burst-Powered Optimization Suite

BurstLOD is a production-grade decimation and optimization suite engineered for high-performance Unity development. Built entirely on the Unity Job System and Burst Compiler, it provides a complete pipeline for generating, refining, and deploying high-quality mesh LODs without slowing down your workflow.

Core Physics & Controller Architecture

The foundation of the asset is the AtmosphericStarshipController, a robust rigidbody-driven system designed to decouple flight logic from input sources. Interface-Driven InputThe system relies on the IShipDriver interface pattern. This abstraction allows the controller to accept inputs from any source—whether it’s the PlayerShipDriver (via Unity Input System) or the SimpleAiPilot—without modifying the core physics loop. This ensures that AI agents are subject to the same physical limitations and flight envelopes as the player. Advanced Aerodynamic ModelMoving beyond simple drag, the controller implements a custom aerodynamic simulation that calculates:

• Linear & Quadratic Drag: Simulates air resistance that scales exponentially with speed, allowing for realistic terminal velocities and "energy bleeding" during maneuvers.
• Directional Drag: applies differential drag coefficients to forward vs. sideways motion, preventing ships from sliding indefinitely like zero-G craft while still allowing controlled drifting.
• G-Force Governance: A built-in limiter monitors angular and linear acceleration, automatically throttling inputs to keep G-forces within a survival threshold defined by the ship’s profile.

Modular Utility AI & Pilot System

The AI architecture employs a decentralized "Brain vs. Pilot" model, separating high-level strategy from low-level execution. The "Brain" (Decision Layer)The AiBrain operates on a configurable "Think Cycle" to evaluate the environment. It utilizes a prioritized list of AiActionSO (ScriptableObjects) to select behaviors. This structure supports complex decision trees, such as:

• Conditional Logic: Evaluates health, proximity, and role (Leader/Wingman) to switch states.
• Hysteresis: Uses distinct Engage/Disengage distance thresholds to prevent state-flickering during combat.
• Behavior Factory: Instantiates behaviors (e.g., BehaviorAttack, BehaviorPatrol) only when needed, keeping memory usage efficient.

The "Pilot" (Execution Layer)The SimpleAiPilot translates the Brain's navigation goals into raw flight inputs. It features a PID Controller (Proportional-Integral-Derivative) flight style, which smooths out rotation and thrust errors. This allows for precise formation flying and organic, non-jittery movement updates that look indistinguishable from player control.

Sensory & Tactical Intelligence

Provider-Based Sensory SystemThe ShipSensorySystem uses a Provider Pattern (ISensorProvider) to abstract physics queries. This allows the system to perform:

• Ground Detection: Calculates altitude for ground-effect physics and safety overrides.
• Obstacle Avoidance: Uses a state-driven scanner that switches from passive forward checks to active, multi-ray searches when an obstacle is detected, generating escape vectors for the pilot.

Centralized Faction ManagementThe FactionManager acts as the tactical authority for the scene. It maintains optimized registries of all active ships, bases, and waypoints. Instead of expensive FindObjectsOfType calls, AI agents query the Manager for instant access to:

• Squadron Logic: Identification of friendly Leaders vs. Followers.
• Threat Assessment: Rapid retrieval of the nearest hostile targets sorted by distance.
• Lifecycle Events: Centralized handling of respawn timers and object pooling logic.

Profile-First Configuration

Similar to the BurstLOD workflow, this asset centers around ScriptableObjects to decouple data from logic. This allows designers to tune the game feel without recompiling code.

• StarshipProfileSO: Defines the physical mass, engine power, maneuverability curves (agility vs. speed), and boost capacity.
• FlightPersonalitySO: Defines the AI pilot's skill level—tuning their PID gains, aggression, and error tolerance.
• WeaponStats: Configures fire rates, projectile prefabs, and guidance logic (locking angles, range).
• EnvironmentProfileSO: Sets global constants for gravity and atmospheric density, allowing for different "planet" feel settings.

Scalability & Optimization

Dual-Mode Simulation (Physics vs. LERP)To support massive scenes (like the included 1024km² demo), the controller features an automatic LOD system for Physics.

• Physics Mode: Nearby ships use the full Rigidbody simulation for accurate collision and interaction.
• LERP Mode: Distant AI agents automatically switch to a Kinematic Linear Interpolation mode. This drastically reduces CPU load by bypassing complex drag and G-force calculations while maintaining visual movement fidelity.

Event-Driven VFX & UIThe StarshipFXController and StarshipHUDManager utilize a C# Event-driven architecture. This ensures that visual effects (particles, sound) and UI updates only consume resources when state changes occur, rather than polling data every frame.

Upcoming Full Version Features

The upcoming full release of the Atmospheric Starship Controller will expand upon this foundation with a comprehensive suite of advanced systems:

• Advanced Avionics: Includes a fully integrated Minimap and a significantly improved targeting system.
• Expanded Combat: Features enhanced weapon guidance logic and a new physics layer for high-fidelity starship collisions and explosions.
• New Environments: Includes a dedicated Space Demo Scene and a specialized Racecourse Scene for testing high-speed maneuvers.
• Next-Gen AI: Deploys a fully expanded Utility-Driven AI system for complex, autonomous decision-making.

Third-Party Notices:

• Asset uses Sci-Fi Sounds by Kenney under the CC0 License; see the Third-Party Notices.txt file in the package for details.

Documentation

• Atmospheric Starship Controller (Demo Controller): https://docs.google.com/document/d/1bK8_wqpfBkHQ05B-Yrv6QLEylCNeUeeQzIWG-dmVrLk/edit?usp=sharing
• BurstLOD (Core System & Runtime API): https://docs.google.com/document/d/1Sk9thBSGfofy9_fclAIcv66rbWjJ4WfckWfhqC3beGU/edit?usp=sharing

Veridian Atmospheric Starship is a production-grade flight framework engineered for arcade-style combat and atmospheric exploration in Unity’s Universal Render Pipeline (URP).

Designed with modularity as a priority, it provides a complete gameplay loop—from physics-based aerodynamics and input handling to a robust Utility AI system—without the overhead of rigid, monolithic scripts. Whether you are building a "Rogue Squadron" style shooter, a racing game, or an open-world sandbox, this asset offers the foundational architecture required to get ships flying immediately.

Physics-Driven Flight Dynamics

The core of the framework is the AtmosphericStarshipController, a Rigidbody-driven system that balances realistic laws of motion with the responsiveness required for arcade gameplay. It moves beyond simple transform translation, calculating forces to simulate weight, drag, and propulsion.

• Advanced Aerodynamics: Implements a custom drag model that calculates linear and quadratic drag based on velocity, simulating atmospheric density. It features directional drag (allowing for drift mechanics) and ground effects that create a "cushion" of lift when flying low.
• G-Force Simulation: Includes a G-Force governor that limits turn rates at high speeds to prevent unrealistic maneuvers, adding weight and consequence to pilot inputs.
• Scalable Fidelity (Physics vs. LERP): Engineered for scale, the controller features a dual-mode system. While the player and nearby enemies use full physics simulation, distant AI agents automatically switch to a low-cost Kinematic LERP mode to maintain high frame rates in large-scale battles.
• Modern Input Integration: Built entirely on Unity’s New Input System, complete with rebindable action maps for Mouse/Keyboard and Gamepad support.

Modular Utility AI System

The asset features a decentralized AI architecture that separates high-level decision-making from low-level flight execution. This "Brain vs. Hands" approach allows for complex, non-cheating AI behavior that adheres to the same physics limitations as the player.

• The Pilot & The Brain: The AiBrain handles strategic decisions (Targeting, State Switching), while the SimpleAiPilot handles the execution, using PID controllers to fly the ship toward navigation goals. This ensures AI pilots actually "fly" the ship rather than sliding along a rail.
• ScriptableObject Behaviors: AI behaviors are modular and data-driven. You can create and tune complex behaviors—such as Patrol, Dogfight, Interceptor, and Sentry—entirely through ScriptableObject profiles, allowing for rapid iteration of enemy personalities without recompiling code.
• Squadron & Faction Logic: A centralized FactionManager handles team rosters, differentiating between Leaders and Wingmen. The AI utilizes this tactical data to form squads, execute coordinated attacks, and respect engagement/disengagement zones.

Integrated Combat Suite

The asset includes a fully operational combat layer managed by the ShipWeaponController and HealthComponent, designed to support diverse weapon types and damage models.

• Multi-Role Weaponry: Support for primary energy weapons (Lasers with accuracy falloff), secondary ballistics (Unguided Rockets and Guided Missiles with target locking), and heavy bombardment payloads (Gravity Bombs).
• Predictive Targeting: The AI leverages a first-order interception calculator to lead targets based on projectile speed and enemy velocity, ensuring capable and dangerous opponents rather than static turrets.
• Gimbal & Turret Logic: Weapons feature configurable gimbal constraints, allowing hardpoints to rotate and track targets independently of the ship’s nose, within defined arcs.
• Lifecycle Management: A robust health and shield system handles damage mitigation, shield regeneration, and death sequences, including automated respawning via the Faction Manager.

Massive Sandbox Environment

To demonstrate the scalability of the framework, the package includes a massive, production-ready demo scene (1024km² playable area) built for the Universal Render Pipeline (URP).

• Open World Architecture: The scene features 5 distinct 64km² islands, each populated with unique biomes, alien flora, and rocky terrain.
• Live Faction Warfare: The environment is populated by two opposing factions with distinct "Home Bases." You will encounter AI squads flying patrol routes, engaging in dogfights, and defending strategic locations with ground-based turrets.
• Free Art Assets: Includes a library of production-ready assets, including Starship prefabs (Player and Enemy variants), modular buildings, turrets, and environmental assets (alien trees, rocks).

Architecture & Configuration

The system emphasizes a Profile-First Workflow, utilizing ScriptableObjects to decouple configuration from code. This ensures that designers can tweak the "feel" of the game without modifying scripts.

• Data-Driven Profiles: Define ship handling (StarshipProfileSO), AI personalities (FlightPersonalitySO), and weapon statistics (WeaponStats) as reusable assets.
• Decoupled FX & UI: Core logic broadcasts state changes via C# Events. The included StarshipFXController and StarshipHUDManager listen for these events to handle visual effects (thruster particles, muzzle flashes) and UI updates, keeping the core physics loop clean.

Ecosystem & Roadmap

Veridian Atmospheric Starship [Lite] is a free preview of the upcoming full Atmospheric Starship Controller. It serves as both a standalone framework and a demonstration of the Veridian performance ecosystem:

• Integration with BurstLOD: This controller is the foundation for the [BurstLOD] runtime demo. When paired with BurstLOD, the ships in this kit support runtime mesh sculpting—allowing lasers to carve holes in armor and rockets to physically dent hulls in real-time.
• Optimized by VeridianImpostors: The massive density of the demo environment is made possible by [VeridianImpostors], which handles the high-performance rendering of the distant alien forests and background infrastructure.

• Works directly in Scene View (Edit Mode, no Play Mode required)
• Frustum-based performance scanning
• Simulated camera far-clip distance
• Layer filtering support
• Supports MeshRenderer & SkinnedMeshRenderer
• Live HUD overlay in Scene View
• Real-time heatmap visualization
• Top offenders detection system
• One-click optimization helpers (GPU instancing / shadows)
• HTML & CSV performance reports export

Important:
Performance metrics (batches, SetPass, draw calls) are estimated for fast editor optimization and may differ from Unity Profiler results.

🔥 Track performance LIVE in Edit Mode and simulate camera movement to see Play-mode behavior instantly — batches, tris, draw calls, materials and more, exactly in the direction your camera is looking. Ultra-fast optimization for mobile, console and PC.

MAG Performance Radar – Scene View HUD + Heatmap 🔥
Stop guessing where your scene becomes heavy.
MAG Performance Radar shows you real rendering cost directly in Scene View, while you design levels — no Play Mode, no Profiler setup, no workflow interruption.Move the camera → instantly see what becomes expensive.
Just like testing gameplay performance, but inside the editor.🚀 What it does

⚡ Live HUD in Scene View with:
- Estimated Batches
- SetPass
- DrawCalls
- Triangles / Vertices
- Materials
- Shadow casters
- Realtime lights
- Simulates camera view:
- Frustum-based analysis
- Custom far-clip simulation
-Radius scan mode

⚡ Real-time heatmap:
- See heavy zones instantly
- Identify problem segments while building maps
- Click any cell → select all objects inside

⚡ Top offenders detection:
- Heaviest objects ranked automatically
- Click to select & frame
- Jump directly to optimization targets
- Instant optimization helpers:
- Disable Cast Shadows (Undo supported)
- Enable GPU Instancing
- Select material / triangle / batch offenders

⚡ Risk scoring:
- LOW / MID / HEAVY performance indicator
- Mobile-friendly thresholds (Low-end profile)
- Understand performance impact at a glance

⚡ Export tools:
- H TML performance report
-CSV path recording
- Share optimization data with team🎯 Built for real production workflows

⚡ Perfect for:
- Mobile games
- Open worlds
- Simulators
- Large environments
- Level designers

⚡ Optimization passes before releaseInstead of entering Play Mode and opening Profiler constantly, you:
- Move camera in Scene View
- See performance cost instantly
- Jump to heavy objects
- Fix them in seconds. Why it’s different
- Unity Profiler shows numbers.

⚡ MAG Performance Radar shows WHERE the problem is.You see:
- which direction is heavy
- which segment breaks performance
- which objects cause it
and you can fix them immediatelyAll without leaving Edit Mode.🧠 Performance metrics (important)
- Batches / SetPass / DrawCalls are estimated using real renderer grouping
(mesh + material + lightmap + shadow settings).They are designed for fast optimization decisions in editor, not as a replacement for the Unity Profiler.Use Radar → detect problems fast
- Use Profiler → validate final resultsThis combo is extremely powerful.🧩 Profiles included

- Low-end mobile (30 FPS)
- Mid devices
- High-end PC/console

⚡ Custom profiles (save your own thresholds)📦 Use cases

- Optimize mobile scenes before publishing
- Detect heavy map zones instantly
- Validate LOD / shadows / batching visually
- Speed up level design workflow
- Reduce iteration time dramatically💬 Ideal for teams & solo devs

⚡ Level designers see instantly if:
- a prop is too heavy
- a segment kills performance
- shadows are overused
materials break batchingNo need to wait for build or profiling sessions.🏁 Result

You optimize while building, not after.Faster workflow.
- Cleaner scenes.

Better performance on every platform.If you build environments, large maps or mobile games, this tool will save you hours every week.

Rigging: Yes

IK bones are included: Yes

Number of Animations: 54

Animation types : In-place

Supported Development Platforms:

Windows: Yes

Mac: Yes

Consoles:Yes

Important/Additional Notes: Camera point is head joint.

| ANIMATION LIST

| PREVIEW VIDEO

| DISCORD SUPPORT

• 54 FPS Gameplay Spell Animations.
• Manny_FP Model Included.
• HDR Background is for showcase purposes only and is not included.

Rigging: Yes

IK bones are included: Yes

Number of Animations: 24

Animation types : In-place

Number of Materials and Material Instances: 1

Supported Development Platforms:

Windows: Yes

Mac: Yes

Consoles:Yes

Important/Additional Notes: Camera point is head joint.

| ANIMATION LIST

| PREVIEW VIDEO

| DISCORD SUPPORT

• 24 Electro Shock Animations in FPS Camera.
• Manny_FP Model Included.
• HDR Background is for showcase purposes only and is not included.

Rigging: Yes

IK bones are included: Yes

Number of Animations: 16

Animation types : In-place

Number of Materials and Material Instances: 1

Supported Development Platforms:

Windows: Yes

Mac: Yes

Consoles:Yes

Important/Additional Notes: Camera point is head joint.

| ANIMATION LIST

| PREVIEW VIDEO

| DISCORD SUPPORT

• 16 Gameplay Shoulder Radio Animations in FPS Camera.
• Manny_FP Model Included.
• HDR Background is for showcase purposes only and is not included.

Rigging: Yes

IK bones are included: Yes

Number of Animations: 74

Animation types : In-place

Number of Materials and Material Instances: 0

Supported Development Platforms:

Windows: Yes

Mac: Yes

Consoles:Yes

Important/Additional Notes: Camera point is head joint.

| ANIMATION LIST

| PREVIEW VIDEO

| DISCORD SUPPORT

• 74 Gameplay Classic Fists Animations in FPS Camera.
• Manny_FP Model Included.
• HDR Background is for showcase purposes only and is not included.

Number of Audio Tracks: 6

Audio Format: WAV

Sample Rate: 44.1 kHz

Bit Depth: 16-bit

Channels: Stereo

Total Duration: 8:06

Loopable: Yes (except the victory jingle)

File Size: 48.8MB

Compatibility: Compatible with the Unity Audio System

Unity Version: 2020.3 or higher recommended

Bring nostalgic charm and positive energy to your game with this Happy 8-Bit Adventure Music Pack, a collection of uplifting chiptune tracks inspired by classic retro games.

This pack is designed specifically for 2D adventure, puzzle, and light RPG games, providing a cohesive musical experience for different gameplay situations such as exploration, menus, ambience, boss encounters, and victory moments.

The music features bright square-wave leads, classic retro bass lines, and playful melodies that create a warm and engaging atmosphere without overwhelming gameplay. Each track is designed to work well as looping background music, making it ideal for long gameplay sessions.

Whether you're building a cozy indie RPG, a relaxing puzzle game, or a cheerful platformer, this soundtrack will help bring your world to life with nostalgic retro charm.

Included Tracks

• Got a Bit Warm
• Happy Adventure
• Happy Exploration
• Happy Ambience
• Happy Boss Battle
• Level Complete (Victory Jingle)

These tracks cover multiple in-game scenarios, allowing developers to quickly add a consistent musical style across their entire game.

Number of textures 16

Texture dimensions (4096x4096, 2048x2048)

Polygon count of [Triangles 54 638]

Minimum polygon count 54 638

Maximum polygon count 54 638

Number of meshes/prefabs 7

Rigging: Yes

Animation count 25

Animation types (Root Motion/In-place): 6/19

LOD information (count, number of levels)

Description

• 🤖 INFORMATION 🤖

This pack contains:

1. Character - Fantasy Cyborg - Queen

• 🤖 FEATURES🤖

1. ✅ Animated (25 animations)
2. 🎨4 skin for each item

• 🤖 About product🤖

This is game-ready animated character It is ideal for RPG, FPS and all related genres.
*sound, FX not included*

Character has Custom skeleton

• Idle - 2
• Roar - 1
• Turn 180 - 1
• Walk - 8
• Death - 2
• Attack - 5
• Gethit - 6

Character:

Triangles: 54 638

Vertices: 36 605

• 🤖 Support🤖

❤️My friend, don't be shy, write to us❤️ - dramaturg34ru@mail.ru

I'm waiting for your every question, whether it's the stupidest question, or if you need some kind of "special character animation".

I will be happy to reply to any of your messages ❤️

We also have a Discord channel where we publish all the news, updates, information about upcoming sales and also hold giveaway

🎁OUR DISCORD 🎁

[Used source file(s)] sizes

File count : over 1000 tiles

Animated: No

Additional: pixelart, 2D topdown view, tilesets, tile resolution 16x16

✨ Over 1000 16x16 pixelart tilesets pack in one BIG package ready to use ! Multiple dungeon type dans style ✨

✅ Multiple dungeons environments :

• classic
• fire
• egyptian
• ancient
• modern
• and more soon !

Note : Please note this package ships a few sample maps, only to get an understanding of how to use the assets. Screenshots above show how to use the assets as well, but do not represent the samples included. The assets are organised in tilepalettes :)

I hope you like it !

🚨 Important : This package is an extension of 2D Cozy RPG - Farming - Tilesets - Characters - Pixelart FULL BUNDLE | 2D Environments | Unity Asset Store

This means it contains additionnal contents, such as tilesets and/or props.

Format: Unitypackage/Wav

Sample Rate: 44.1kHz

Bit depth: 24

Stereo

For any kind of support - contact coco.audiolibrary@gmail.com

"UI SFX - 100 Synthetic sounds" offers a variety of click, button, menu, confirm, error and loading sounds.

Highly suitable for almost any game genre!

No AI has been used during the creation of any of the Coco Audio Library packs.

Samplerate: 48 KHz

Bit depth: 24 bit

Format: .wav (MP3 is included in a sub folder)

Loopable: yes

Additional: Stereo

Total Duration:

• One shots 01:04.35.394
• Loops: 00:59:28.253

Whispers from Beneath the World

Part I: Low End

A collection of 20 high-quality dark ambient soundscapes designed for horror, dark fantasy, sci-fi and atmospheric game environments.

These atmospheres feature sub-bass drones, metallic textures, rumbling basses, pulsating tones, low end percussion, waving noises and unsettling sonic landscapes which are perfect for creating tension, dread, and mysterious environments.

Ideal for:

• (Sci-fi-) Horror games
• Dark fantasy worlds
• Underground environments
• Eldritch or supernatural settings

Each soundscape includes three versions:

• One-Shot – ambience without looping

• Loop Start – begins a seamless loop (no reverb tail at the start)

• Continuous Loop – seamless looping version with natural reverb tail at the beginning

Additional documentation, durations, naming convention and tempo is included with a complete track list (XML, PNG and PDF).

If you have any questions, feel free to reach out.

Christian Mietke

Number of textures: 7

Texture dimensions :2048*2048

Polygon count of [Cartoon Cat]

Vertis: 7222

Face: 7260

Tris: 14200

Number of meshes: 2

Number of prefabs: 2

Rigging: Yes

Animation count: 18

Animation type list: Walk_Forward,Walk_Backward,Run,Jump,Idle_01,Idle_02,Death,Sleep,StandUp,Angry_Idle,Happy_Idle,Crying,Setting,Roll_01,Roll_02,Fight_01.Fight_02,Win.

UV mapping: Yes

Types of materials and texture maps (Base Color Map,Normal Map and MetallicSmoothness PBR)

1. Cartoon Cat Caharacter:

A low-poly Catwith hand painted high quality texture.

This Assets use AR,VR,mobile Game,pc game and any different projects.

All assets are created in a low poly art style.

The material setups are simple and you are able to customize them easily.Use unity standard material.

Number of textures: 8( Basecolor map ,Normal Map and MetallicSmoothness_Map)

Texture dimensions: 2k

Polygon count of [Winter Penguin]

Vertis: 7503

Face: 7514

Tris: 14856

Number of meshes: 2

Rigging: Yes

Animation count: : 16

Walk_01,Walk_02,Walk_03,Idle_01,Idle_02,Idle_03,Run,Idle_Sleep,,Sleep,Death,Swim,Swim Attack,Swim Eat,Hit,Attack,StandUp.

Animation type list: RootMotion & In Place

UV mapping: Yes, Non-Overlapping

Winter Penguin Character:

A low-poly Penguin with hand painted high quality texture.

This Assets use AR,VR,mobile Game,pc game and any different projects.

All assets are created in a low poly art style.

The material setups are simple and you are able to customize them easily.Use unity standard material.

Textures Size:

2048x2048

Number of textures: 8( Basecolor map ,Normal Map and MetallicSmoothness_Map)

Texture dimensions: 2k

Polygon count of [Penguin]

Vertis: 7503

Face: 7514

Tris: 14856

Number of Animations: 132

Animation types: Root Motion & In place (optional)

Umbrella Action Pack is a high-quality animations.
This pack includes a wide range of combat and movement animations suitable for action, fighting, RPG, and adventure games.

The pack supports Root Motion and In-Place animations, giving developers flexibility when integrating them into gameplay systems.

✨ Key Features

• 130+ high-quality humanoid animations
• Umbrella-style combat attacks and combos
• Ground and aerial combat animations
• Crouch movement and defensive states
• Dodge, block, hit, and knockdown reactions
• Directional locomotion and turning animations
• Fully compatible with Unity Mecanim (Humanoid)
• Optimized for real-time gameplay

🎮 Animation Categories

• Ground combat attacks and combos
• Defensive blocking and dodge animations
• Crouch movement and transitions
• Walk, run, strafe, and turning animations
• Hit reactions and knockdown sequences
• Aerial / flying combat animations

NOTE : Umbrella model not Included

Suitable for action, fighting, RPG, and stylized combat games.

The Problem That Started It All

While developing my 2.5D game, I constantly faced a frustrating workflow issue: I needed multiple sprites to animate in sync with each other, positioned throughout a 3D environment. But every time I opened my pixel art editor, I lost all spatial context. I couldn't see how sprites related to each other in 3D space, leading to constant back-and-forth between my pixel art software and Unity.

So I built a solution.

Edit Pixel Art Without Leaving Unity

Pixel Art Scene Editor lets you paint and edit sprites directly in the Scene view, with full 3D spatial awareness. See your sprites exactly as they'll appear in-game, maintain perfect alignment with neighboring sprites, and iterate rapidly without ever leaving Unity.

The workflow is simple:

1. Select a sprite in your scene
2. Activate the tool and start painting
3. See changes in real-time, in full 3D context
4. Save your edited sprite (original stays safe)
5. Optionally add it as a Timeline keyframe
6. Move to the next sprite and repeat

Core Painting Tools

• Brush Tool (1) - Paint pixels with adjustable brush size (1-5 pixels)
• Eraser Tool (2) - Remove pixels with transparency
• Color Picker Tool (3) - Sample colors directly from your sprite
• Fill Tool (4) - Flood fill with intelligent queue-based algorithm

Keyboard shortcuts (1-4 keys) let you switch tools instantly while painting.

Symmetry Painting

• Horizontal Mirror - Paint once, mirror across vertical axis
• Vertical Mirror - Paint once, mirror across horizontal axis
• Both Axes - 4-way symmetry

Pixel Grid Overlay

• Semi-transparent grid for pixel-perfect precision
• Toggle on/off

Canvas Expansion

• Add pixels to any edge (left, right, top, bottom)
• Pivot automatically adjusts - sprite stays in exact world position
• Preview new size before applying
• For adding borders or extending sprites without breaking scene references

GPL Palette Support

• Load GIMP Palette (.gpl) files

Real-Time 3D Preview

• See exactly how your sprite looks in the scene
• No more guessing how edits will look in-game

Timeline Integration

One-Click Sprite Animation Keyframes

1. Open Timeline with your sprite's GameObject
2. Paint your sprite in the Scene view
3. Click "Save to Asset and Add Timeline Key"
4. A keyframe is automatically created at the playhead position

Timeline integration features

• Creates Animation Clips automatically if needed
• Updates existing keyframes instead of duplicating
• Only enables when Timeline window is open
• Validates track bindings before attempting to add keys

Convenient File Management

Non-Destructive Editing

• Originals always protected - Never modifies source sprites
• Creates edited copies with configurable naming
• Auto-suggests save location based on original sprite
• Optional custom suffix (default: "_edited")

Auto-Increment Filenames

• Automatically appends _01, _02, _03... to new saves
• Finds next available number automatically

Exact Pivot Preservation

• Uses Unity's ISpriteEditorDataProvider API
• Maintains pixel-perfect pivot positioning
• Your sprite stays exactly where it should in the scene
• No manual pivot adjustments needed after saving

Proper Import Settings

• Point filtering (pixel-perfect rendering)
• Uncompressed format (maximum quality)
• sRGB color space (correct colors)
• Matches original sprite's pixels-per-unit
• Everything configured automatically

Full Undo/Redo Support

• Per-stroke undo - Each paint action undos individually
• Integrated with Unity's undo system (Ctrl+Z / Cmd+Z)
• Works across all tools (paint, erase, fill, canvas expansion)
• Undo history preserved throughout editing session

Workflow Features

Timeline Override Protection

• Detects when Timeline tries to change your sprite
• Shows clear warning in Scene view
• Automatically restores your editable sprite
• Prevents accidental overwriting of your work

How to use:

1. Open: Window > Pixel Art Scene Editor
2. Click: "Activate Tool"
3. Select: Any sprite in your scene
4. Paint: Use tools or keyboard shortcuts (1-4)

Documentation & Support

• Quick Start Guide
• Video Guide

Roadmap

Planned Features:

• Opacity slider for semi-transparent painting
• Line tool
• Spray paint tool with randomization
• Additional keyboard shortcut customization

Future Release:

• Layer support for complex compositions
• Layer blending modes
• Layer visibility controls
• Aseprite file format import/export
• Onion Skin

⚠️ PLEASE NOTICE - a few technical remarks :

• This tool was designed for editing sprites within a 3D enviroment to make the development of 2.5D games easier. I have not tested its use in a 2D project.
• Tool was only tested editing sprites in a 3D enviroment.
• Unity's 2D Sprite package needs to be installed from the Package Manager in order to use the tool. It is not installed by default when you create a 3D project. You can also install the entire 2D list of packages.
• I have worked hard to eliminate all bugs. If you do come across one, please contact me with details so it can be fixed!
• If you have any suggestions or requests for future versions, please don't hesitate to contact me!

Built By a Solo Developer, For Fellow Developers

This tool was born from real needs I faced while developing my game. I created it to streamline my own workflow and quickly realized it could help many others facing the same challenges.

If you genuinely need this tool but can't afford it, please contact me directly—we'll work something out. But if purchasing is within your means, your support directly funds continued development of this tool and helps me dedicate more time to creating useful resources for the community (as well developing my own game).

Thank you for considering it! 🙏

Supported Platforms

• Windows standalone
• Android
• Extensible to additional platformsiOS
  

Snapshot System

• JSON based snapshot format
• Stores total size and asset level breakdown
• Designed for version control and CI artifact storage
• Supports multi platform separation

Diff Engine

• Compares two snapshots deterministically
• Calculates absolute and percentage deltas
• Ranks top N increases and decreases
• Identifies new and removed items
• Grouping by path and asset type
• Extensible grouping strategy

Budget System

• Per platform total size budgets
• Optional per category budgets
• Configurable thresholds
• Clear violation output
• Non zero exit code for CI failure

CI Integration

• Batchmode compatible entry point
• Command line arguments for snapshot comparison
• JSON result output
• Optional Markdown summary
• Exit code based on rule evaluation

Editor Integration

• Dedicated EditorWindow
• Snapshot list with timestamps and platform indicators
• Baseline and Current selection
• Delta summary cards
• Sortable diff table
• Export summary button

Dependencies

• Unity 2021 LTS or newer recommended
• No external services required
• No cloud dependency

Package Contents

• Editor UI
• Snapshot system
• Diff engine
• Budget configuration system
• CI command line runner
• Example configuration

Stop build size regressions before they ship. Build Size Guard automatically records build size snapshots, compares two builds, shows exactly what changed, and can enforce size limits (budgets) locally and in CI.

✅ What you get

• Automatic build snapshots saved per build target (so you can track history over time).
• Compare any two builds and see the exact delta: total size change + where it came from.
• Top contributors list (what grew the most, what shrank, what is new).
• Grouping views so you can understand changes fast (by folder/path and by category).
• Budgets and enforcement to fail fast when size grows beyond your rules.
• CI friendly outputs so teams can gate regressions in pipelines.

🔍 Find the cause in minutes

When a build grows, the question is never “did it grow?”, it’s “what specifically changed?”

Build Size Guard highlights:

• Largest increases (new or expanded assets)
• Largest decreases (useful for validating optimizations)
• New entries (assets that suddenly started contributing)
• Changed distribution across categories (useful for texture/audio bloat)
• Target-specific differences (Android vs iOS vs Windows can diverge)

💸 Budgets (size limits)

Set budgets that match how real projects work:

• Total build size budget per target
• Optional rules like max allowed regression per snapshot comparison
• Optional category budgets (for example: textures, audio, meshes, shaders, managed code, native/plugins) depending on what Unity can report for your target

When a budget is violated, you can make it loud:

• Editor feedback for local builds
• CI failure for automated checks (non-zero exit style workflow)

🧰 Typical workflow

1. Build normally.
2. Build Size Guard records a snapshot automatically.
3. Release baseline vs currentOpen the tool and Compare:
   Latest vs previous
   
4. Identify the top culprits, then fix the real cause.
5. Add budgets to prevent the same regression from returning.

🤖 Designed for teams and CI

• Works for solo devs who want quick answers.
• Works for teams who need enforcement and history.
• Generates shareable reports so regressions are easy to review in PRs and build logs.

🧩 Implementation notes

• Editor-only tooling (no runtime footprint).
• Uses Unity’s build reporting data to track size and changes.
• Best results when you keep a stable baseline snapshot for each target and compare against it.

🏠 Homepage

📂 Documentation

💬Support