Asset Store newest packages

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

Key Features:

• 8-direction grid-based movement

• Turn-based engine using IAction pattern (1 action = 1 turn)

• Shadowcasting Field of View with explored memory

• A* pathfinding (8-direction, uniform cost)

• Melee combat system

• Unity-free Core simulation layer

• Modular assembly structure (URF.Core, URF.Unity)

• Weighted monster spawning configurable via Inspector

• Gold and Potion item system

• Inventory with ItemChanged event

• Potion hotkey and Wait hotkey

• Stairs and procedural floor progression

• Run statistics tracking (seed, floor, kills, time survived, best runs)

• Full snapshot Save/Load (restores monsters, pickups, stairs)

• Game Over overlay with fade and run summary

• Restart run hotkey with new seed generation

• Character sheet popup

• TextMeshPro HUD

• Built-in Render Pipeline compatible

• Input System with legacy fallback support

• No Update polling for gameplay logic

• Event-driven architecture

• Inspector-driven monster configuration

• Deterministic turn resolution

• Clean separation between simulation and presentation

Ultimate Roguelike Framework (URF) is a professional-grade foundation for building traditional grid-based roguelikes in Unity 6.

This is not a prototype.

It is a clean, extensible architecture built around a Unity-free Core simulation layer and a modular Unity host layer. Designed for developers who want clarity, structure, and a scalable base to build upon.

Core Features

• True 8-direction grid-based movement
• Turn-based engine using IAction pattern (1 action = 1 turn)
• Shadowcasting Field of View with explored memory
• A* pathfinding (8-direction, uniform cost)
• Melee combat system
• Weighted monster spawning via Inspector
• Gold and Potion item system
• Inventory with event-driven updates
• Stairs and procedural floor progression
• Run statistics (seed, floors, kills, time survived)
• Snapshot Save/Load system (restores monsters, pickups, stairs)
• Game Over overlay with run summary
• Character sheet popup
• TextMeshPro HUD
• Built-in Render Pipeline compatible

Clean Architecture

URF's main assembly is split into two:

URF.Core (Unity-free)

• Turn engine
• Combat system
• FOV
• Dungeon generation
• Items
• Run statistics
• No UnityEngine references

URF.Unity

• Scene host
• Input handling
• Save/Load glue
• Runtime wiring
• HUD
• Character sheet
• Game Over overlay

This separation makes the simulation logic independent from rendering and Unity scene code, making it easier to extend, test, and maintain.

Save/Load system restores:

• Floor number
• Player position and stats
• Inventory
• Stairs position
• Monster positions and HP
• Pickup positions

This is a full floor snapshot, not just meta progress.

Designed for Extension

This Simple Edition is a stable foundation intended to be extended.

You can easily add:

• New monster archetypes through the Inspector
• New item types
• Status effects
• Ranged combat
• Abilities
• Loot systems
• Advanced AI

The architecture is built to scale without rewriting the core systems.

Requirements:

• Unity 6 (6000.x)
• Built-in Render Pipeline
• TextMeshPro (included with Unity)
• Input System (enabled by default in Unity 6)

What This Package Is Not

• Not a complete RPG
• Not a skill tree system
• Not a multiplayer framework
• Not a visual art pack

It is a clean traditional roguelike foundation.

Built for...

• Developers building traditional roguelikes
• Developers who want structured, modular code
• Developers who value engine separation and clean design
• Indie developers scaling from prototype to production

Commercial Use

You may use Ultimate Roguelike Framework in commercial or non-commercial projects under the Unity Asset Store EULA.

Credit is not required but is appreciated.

About the Author

Created by Jonathan Concepcion, developer of OneBit Adventure and Rogue Together.

URF was built from real production experience creating grid-based roguelikes.

Render Pipeline:

• Universal Render Pipeline (URP)

Unity Versions:

• 2021 LTS

• 2022 LTS

• 2023 LTS

• 2024 and newer

Platforms:

• Windows

• Mac

• Linux

• WebGL (URP-supported features only)

• Mobile (performance varies by device)

Included Files:

• VHS_Final_Master.shader

• Custom Inspector (VHSInspector.cs)

• Custom Renderer Feature / Injector (VHSInjector.cs)

• Demo Scene (preconfigured camera + material)

• Example Material

• Documentation PDF

• Organized folder structure (Demo, Documentation, Shader, Scripts, Pipeline)

Dependencies:

• URP Renderer with Scriptable Renderer Feature support

• No external packages required

Features:

• Fisheye lens distortion

• Radial DSLR blur

• Chromatic aberration (flare + RGB split)

• Color bleeding / tape lag

• Glitch bands and RGB bursts

• Scanlines + warp

• Grain (BW + chromatic)

• Flicker, jitter, vertical jump

• Blackout / dropout events

• Fully toggle-based modular system

File Structure:

Assets/

VHS/

Demo/

Documentation/

Pipeline/

Scripts/

Shader/

Materials/ (optional)

Textures/ (optional)

Known Limitations:

• Built-in Render Pipeline is not supported

• HDR

VHS FINAL MASTER – Analog Horror & Retro Distortion Suite (URP)

Bring authentic VHS, CRT, and analog horror distortion to your Unity project with the Fringe Logic VHS Final Master shader. This is a complete, modular, screen‑space effect designed for URP, featuring a full stack of retro artifacts, tape damage, lens distortion, glitch bands, scanlines, color bleeding, grain, jitter, and more.

Perfect for:

• Analog horror

• Retro aesthetics

• Found‑footage games

• VHS/CRT UI overlays

• Stylized glitch effects

• Cinematic distortion

The shader is fully modular — every effect can be toggled on/off individually. No scripting required.

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

FEATURES

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

• Blackout / Tape Dropout

• Fisheye Lens Distortion (Hybrid Projection)

• DSLR‑Style Radial Blur (Edge‑Weighted)

• Vignette & Border Darkening

• Chromatic Aberration (Radial Flare)

• Constant RGB Split

• Color Bleeding / Tape Lag

• Glitch Bands (Head Clogging)

• RGB Burst Events (Random or Scrolling)

• Static Grain (BW)

• Chromatic Color Grain (Chunky RGB Noise)

• Scanlines (Density, Speed, Rotation, Warp)

• Scanline Warp Layer

• Screen Flicker

• Vertical Jump

• Frame Jitter (Micro‑Shake)

• Fully toggle‑based system

• Clean inspector layout

• URP‑native blit pipeline

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

WHAT’S INCLUDED

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

• VHS Final Master Shader (URP)

• Custom Inspector

• Custom Renderer Feature (Injector)

• Demo Scene (ready to run)

• Documentation PDF

• Example Material

• Organized folder structure

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

EASY SETUP

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

1. Add the included renderer feature to your URP Renderer.

2. Assign the VHS material.

3. Press Play — the effect is active immediately.

4. Adjust settings in the material inspector.

No scripting required.

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

DEMO SCENE

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

The included demo scene shows the effect immediately when entering Play mode.

The camera is pre‑configured with the injector and material.

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

PIPELINE & COMPATIBILITY

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

• Render Pipeline: Universal Render Pipeline (URP)

• Unity Versions: 2021 LTS, 2022 LTS, 2023 LTS, 2024+

• Platform: Windows, Mac, Linux

• Works in 2D and 3D projects

• Works with UI and world‑space cameras

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

SUPPORT

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

For support, updates, or inquiries:

Email: your-email-here

Portfolio: https://yourusername.github.io/

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

Jelly Loop Jam – Sorting Puzzle Template + Editor is a complete game development template designed for creating and customizing jelly color-sorting puzzle games where players tap bowls to collect matching jelly balls extracted from a softbody image on a conveyor belt. The gameplay structure is inspired by popular hyper-casual sorting titles, such as Sand Loop, Sand Jam, and Jelly Loop.

It includes a full gameplay loop, Voronoi-based softbody jelly physics simulation, automatic level generation from photographs, three in-game boosters, and a fully featured in-game level editor with JSON import/export support. All systems are modular, data-driven, and easy to extend, making this template ideal for game jams, rapid prototyping, and production-ready casual or hyper-casual puzzle games.

🕹️ Try First: Browser Demo | Android Demo

OUR ADVANTAGES

• Developer-oriented architecture
• Clear documentation and setup workflow
• Built-in level editor and editor utilities
• Easy visual, color, and gameplay customization
• Clean, modular, and extendable Unity codebase

TEMPLATE INCLUDES

🪼 Jelly Sorting Puzzle Gameplay ‎ ‎ ‎ ‎ 

• Voronoi-based soft-body jelly ball physics simulation
• Tap-to-sort bowl mechanic with BFS pathfinding click detection
• Conveyor belt system with jelly extraction and liquid fill animations
• Color-coded bowls with mystery bowl support (hidden colors)
• Smooth and satisfying hyper-casual puzzle gameplay loop
• Voronoi-based soft-body jelly ball physics simulation
• Tap-to-sort bowl mechanic with BFS pathfinding click detection
• Conveyor belt system with jelly extraction and liquid fill animations
• Color-coded bowls with mystery bowl support (hidden colors)
• Smooth and satisfying hyper-casual puzzle gameplay loop

🏗️ Level Editor & Data System ‎ ‎ ‎ 

• 220 Unique levels included
• Built-in level editor scene integrated with the Unity Editor (no Play mode required)
• Visual bowl grid editor with Select Bowls and Edit Cells modes
• Image import tool with inline palette editor and re-rollable K-means++ color seeds
• Automatic color distribution based on image coverage
• JSON-based level export and import system
• Auto Level Generator for batch-creating levels from image folders
• Configurable ranges for colors, grid size, mystery bowls, and booster countsBuilt-in level editor scene integrated with the Unity Editor (no Play mode required)
• Visual bowl grid editor with Select Bowls and Edit Cells modes
• Image import tool with inline palette editor and re-rollable K-means++ color seeds
• Automatic color distribution based on image coverage
• JSON-based level export and import system
• Auto Level Generator for batch-creating levels from image folders
• Configurable ranges for colors, grid size, mystery bowls, and booster counts

🎮 Boosters & Gameplay Systems ‎ ‎ ‎ ‎ 

• Three built-in boosters: Extra Slot, Shuffle, and Magic Pick
• Level-based booster unlock system with tutorial popups
• Extendable booster architecture for adding custom abilities
• Flexible per-level booster configuration through JSON

🎨 Color & Visual Tools ‎ ‎ ‎ ‎ 

• K-means++ image quantization system for converting images into jelly grids
• Re-rollable seed system for generating varied color palettes
• Voronoi soft-body rendering with adjustable physics parameters (gravity, damping, jiggle)
• Easy replacement of materials, models, and visual effects

🧪 Developer & Debug Tools ‎ ‎ ‎ ‎ 

• In-game Developer Settings panel for level navigation and ad testing
• Keyboard shortcuts for fast level switching and booster unlocking
• Clean namespace structure
• Modular GameManager architecture

🎨 Customization Friendly ‎ ‎ ‎

• Easily replace visuals, UI elements, and animations
• JSON-driven level configuration with no hardcoded gameplay rules
• Generate new levels instantly by importing your own images
• Designed as a flexible foundation template rather than a locked system

📱 Mobile Ads Network ‎ 

• AdMob integration for banner, interstitial, and rewarded video ads
• Dummy ad provider for safe testing in the Unity Editor without a real AdMob account

💿 Supported Platforms ‎ ‎ ‎ ‎ 

• iOS
• Android
• WebGL
• Desktop

📄 Documentation

Online Documentation

Includes step-by-step guides for:

• Setting up the game scene and running your first level
• Using the Level Editor to design and configure bowl grids
• Importing images and generating levels with K-means++ quantization
• Exporting and importing JSON level files
• Adding and customizing boosters
• Extending the template for your own jelly sorting or hyper-casual puzzle game

📬 Support

If you have any questions or need assistance, feel free to get in touch:

📧 Email: ragendom@gmail.com

Technical Details

Asset Count

• 28 Unique Assets
• Variety of urban and utility props (Vehicles, Signage, and Street Furniture)
• Fully configured Prefabs included for all models
• StylisedPropsLayout scene included for quick demonstration

Included Assets Vehicles & Transport

• Ambulance2, PoliceCar2, HeliPad Street Furniture & Utility
• Bench, ParkBench, OutDoor Sitting, OutDoorStool, TrashCan, TrashBag, MailBox, VendingMaachine Signage & Traffic Control
• BusStopSign, NoEntrySign, NoParkingSign, SignBoard1, SignBoard2, StreetLamp, StreetLamp2, TrafficCone, Barrier, Barrier2 Buildings & Structures
• Building, LightHouse, WindMill Props
• Barrels, Bushes, Crates

Polygon / Vertex Count

• All assets are optimized for high-performance real-time rendering.
• General Props:
• Vertex Range: 300 – 1,800 vertices
• Clean topology designed for mobile and stylized PC games.
• Game-ready meshes with optimized geometry for VR and indie projects.

Textures

• Custom stylized textures including multiple atlases
• Format: PNG
• Resolution: 1024x1024
• Textures Included: * ColorPallete
• TextureAtlas5
• Specific sign textures (no-parking, bus sign, etc.)

Materials

• Materials are pre-configured with emission support
• Materials Included: * BusStopSign
• GoldEmission
• PurpleEmission
• All materials are properly assigned to prefabs for immediate use

Prefabs

• All models are available as ready-to-use prefabs inside:
• Assets/_Stylized_Props_Utility_Pack/Prefabs/
• Each prefab includes: * Standardized scale
• Correct pivot placement
• Pre-assigned materials and clean hierarchy

Performance

• Lightweight and mobile-friendly
• Highly optimized draw calls using the included TextureAtlas and ColorPallete
• Suitable for city builders, casual simulators, and stylized low-poly environments.

Scene Included

• StylisedPropsLayout demo scene included
• Demonstrates optimal asset placement and lighting setup.

Stylized Props Utility Pack is a collection of stylized 3D environment assets designed to help developers quickly create urban, roadside, and utility-themed scenes in Unity. The pack includes a variety of props such as vehicles, street lamps, barriers, benches, buildings, signboards, trash cans, bushes, and other environmental objects.

All assets are provided with FBX models, materials, textures, and ready-to-use prefabs, making them easy to integrate into any Unity project. The organized folder structure allows developers to quickly locate assets, while the included demo scene demonstrates how the props can be combined to create a complete environment.

This pack is suitable for simulation games, runner games, city environments, and stylized open-world projects, helping developers build scenes efficiently while maintaining a consistent stylized look.

• Unity version: 6000.3+ (Unity 6.3+).
• Type: Editor-only tool (no runtime dependency).
• Supported renderers: MeshRenderer, SkinnedMeshRenderer.
• Window path: Tools > Mesh LOD Visualizer.
• Features:
• Live LOD preview/range scrubber with camera marker.
• Scene overlay monitor with compact HUD.
• Scene Camera / Main Camera lens workflows.
• Renderer LOD bias controls and preview follow/lock flow.
• Mesh LOD details (triangles, vertices, transition distances).
• Scan Candidates for missing LOD data and heavy LOD0 meshes.
• Compatible with Built-in, URP, and HDRP editor workflows.
• Limitation: requires Unity Mesh LOD APIs available in Unity 6.3+.

Mesh LOD Visualizer for Unity 6 is an Editor extension focused on practical LOD tuning workflows. It helps you inspect how Mesh LOD levels switch, preview transition distances, and compare camera-driven behavior in Scene and Game workflows.

The tool provides a live LOD preview bar, scene monitor overlay, per-LOD triangle/vertex visibility, and direct controls for renderer bias and preview/override modes. It also includes a candidate scan workflow to quickly find meshes with missing Mesh LOD data or heavy LOD0 budgets and jump to them for correction.

This package is built for technical artists and optimization workflows that need clear, repeatable LOD validation inside the Unity Editor.

High-Performance UI Architecture

Built entirely with Unity’s modern UI Toolkit framework (VisualElements, UXML, USS).
No legacy IMGUI code ensures minimal editor overhead, smooth resizing, and stable performance.

Optimized for Large Projects

Virtualized ListView and GridView rendering display only visible elements, maintaining smooth navigation even with 5,000+ materials.

Responsive Interface

Flexbox-based responsive layout scales correctly across different resolutions, DPI settings, and 4K monitors.

💾 Data & Project Safety

ScriptableObject-Based Storage

Collections and folders are stored as standard .asset files using ScriptableObjects.

• Version control friendly (Git, PlasticSCM, Perforce)
• Reliable serialization
• Team workflow ready

Non-Destructive Workflow

The tool reads data via the AssetDatabase API and never modifies materials unless explicitly triggered by the user.

Clean Project Structure

Local user preferences are stored in EditorPrefs, avoiding temporary project files or hierarchy clutter.

🧠 Analysis & Processing

Smart VRAM Estimation

Memory usage is calculated using Profiler.GetRuntimeMemorySizeLong, with automatic texture reference de-duplication for accurate global statistics.

Duplicate Detection Algorithm

Potential duplicates are detected by comparing shader hash, active keywords, and texture references.

Asynchronous Preview Generation

Material previews load asynchronously to prevent editor freezes during browsing.

🔌 Compatibility

• Pipeline Agnostic: Built-in, URP, HDRP
• Unity Version: Tested and compiled for Unity 6 (2023.3+) and newer
• Editor Only: No runtime overhead

Analyze. Organize. Control.

📘 User Manual | 🛟 Support | 🎬 Demo Video

Stop drowning in unorganized materials. Apex Material Pro is the modern command center designed specifically for Unity 6 to help you master your project's visuals without modifying your assets or project structure.

Built with UI Toolkit, it integrates seamlessly with the Editor's dark theme for a fast, native experience.

🔍 ANALYZE – Know Your Costs

Stop guessing where your performance cost comes from.

• Scene & Project Scans — Detect all materials used in your scene or entire project.
• Material Cost Score — Identify expensive materials instantly (Low / Medium / High).
• Texture Analysis — Inspect resolution, format, and VRAM usage for every texture map.
• Shader & Keyword Tracking — Monitor active shader keywords and rendering settings.
• Duplicate Detection — Find identical materials (same shader, keywords, textures).
• Interactive Statistics — Click stats and graphs to filter results instantly.

📦 ORGANIZE – Build Your Workflow

Create a clean material workflow without changing your project structure.

• Custom Collections & Folders — Group materials logically using drag & drop.
• Favorites System — Keep important materials instantly accessible.
• Non-Destructive Organization — No file moves, no project restructuring.
• Persistent Collections — Stored as lightweight assets, shareable with your team.
• Grid & List Views — Visual browsing or data-driven inspection.

🎮 CONTROL – Take Action

Interact with your materials without leaving the tool.

• Select all objects using a material in one click.
• Toggle GPU Instancing instantly.
• Locate assets directly in the Project window.
• Filter materials by usage, rendering mode, or texture size.

Everything you need in one place.

SmartCopy copies and pastes all modifiable serializable fields across different unity objects, including:

• Public fields
• Private fields marked with [SerializeField]
• Fields marked with [HideInInspector]
• Nested serialized data

SmartCopy is a Unity Editor tool that lets you copy and paste serialized field values between any Unity objects by intelligently matching property path and type. It works across any built-in components, MonoBehaviours, and ScriptableObjects — even if they are unrelated classes — as long as their serialized fields match.

Learn more about the package's code here.

Key Features

• Global Mode: Automatically adds picker buttons to every compatible field project-wide. No manual setup required.
• Hierarchy Cycling: Use the Mouse Wheel while hovering to cycle through parent/child objects—perfect for picking a specific Button or Panel within a complex UI.
• Marquee Selection: Batch-assign multiple objects to Lists or Arrays by dragging a selection box (Shift + Drag) in the Scene View.
• Type Filtering: Automatically detects the required field type and filters out invalid targets.
• Quick Removal: Right-click objects directly in the Scene View to remove them from a List or Array.
• Attribute Support: Includes a [GameObjectPicker] attribute for explicit control when Global Mode is off.

GameObject Picker turns the Unity Inspector into an interactive experience. Instead of scrolling through hundreds of nested objects in your Hierarchy, you simply click the "dropper" icon on any field and pick your target directly from the scene.

Smart & Context-Aware:The tool isn't just a blind selector; it understands Unity’s type system. If a field requires a Light component, it will automatically filter the scene and only allow you to pick objects that contain a Light.

Who is this for?

• UI Developers: Navigate deep Canvas hierarchies effortlessly.
• Level Designers: Populate arrays and references for massive environments in seconds.
• Programmers: Speed up testing and reference assignment during rapid prototyping.

• Requires: BTGraph / BTGraph PRO
• Unity Version: (insert your supported version, e.g. 2021.3+)
• Fully compatible with BTGraph Core & Pro
• Event-driven dialogue runtime
• IQuestService interface for custom quest systems
• No reflection or heavy runtime dependencies
• No required third-party packages
• Works in 2D & 3D projects
• Zero external UI dependency
• Clean namespace separation

Build Complete Conversations — Not Just Trees

BTGraph – Dialogue & Quest Pack transforms your behaviour trees into fully interactive narrative systems.

Create branching dialogue, conditional choices, quest-aware conversations, and reactive NPC interactions — all inside the BTGraph editor.

No custom nodes required.
No hard-coded logic.
No external dialogue framework needed.

🎭 Dialogue Features

• Start / End Dialogue nodes
• Dialogue Line node (speaker, tags, optional metadata)
• Choices node with:
  Visible conditions
  Enabled conditions
  On-select effect lists
• Jump / Flow control
• Continue / Await input
• Random / Weighted dialogue (barks support)
• Once & cooldown gating

The included Dialogue Runner and Simple UI prefab allow immediate use without writing additional systems.

🧭 Quest Integration (Out of the Box)

Connect dialogue directly to your quest logic.

• Offer, complete, fail quests
• Set and advance quest stages
• Add quest progress
• Set / clear flags
• Raise quest events
• Wait until quest conditions are met
• Branch based on quest state, stage, progress, or flags

Includes a lightweight SimpleQuestService for immediate testing and prototyping.

For production use, implement the provided IQuestService interface to connect your own quest system seamlessly.

⚙️ Professional Architecture

Designed with clean integration in mind:

• UI-agnostic runtime (event-driven Dialogue Runner)
• Blackboard-compatible service resolution
• Minimal allocations and tick-safe nodes
• Modular design that extends BTGraph cleanly
• Works with existing BTGraph projects

This pack does not replace your quest system — it connects to it.

🎮 Example Use Cases

• NPC quest givers
• Reactive conversations based on player progress
• Branching RPG dialogue
• Dynamic city barks
• Multi-stage objective updates
• Conditional turn-in conversations

📦 What’s Included

• Dialogue nodes
• Quest integration nodes
• Condition and effect nodes
• Dialogue Runner component
• Simple Dialogue UI prefab
• SimpleQuestService demo implementation
• Example scenes
• Documentation

Editor version: 2022.3.26f1 and above

Right-click → generate MonoBehaviours, ScriptableObjects, enums, interfaces, and more.

What this tool does

C# Script Templates is a lightweight Unity Editor extension that adds a dedicated Project window context menu for creating C# scripts from templates. It removes repetitive boilerplate and eliminates the “create MonoBehaviour → delete inheritance → rewrite class” loop.

Key features

• Right-click → C# Script Templates → create scripts instantly.
• Root namespace friendly: templates can wrap code in the configured root namespace (and format cleanly using indentation-safe templates).
• Editor-only: no runtime overhead, no scene objects, no dependencies.

Included creators/templates

MonoBehaviour

• MonoBehaviour Script
• Abstract MonoBehaviour
• Virtual MonoBehaviour

Data / Assets

• ScriptableObject Script

C# Basics

• Empty Class
• Static Class
• Interface

Enums

• Enum
• Serializable Enum

Customization

Add your own templates by dropping .cs.txt files into your templates folder and wiring a menu item to create them—use this package as a starting point for a studio-wide standardized script workflow.

It's a production-ready Unity toolkit for building clean, decoupled gameplay communication without fragile object references.

It combines three core workflows in one package:

• EventBus<T> for global, code-first events between systems.
• ScriptableObject Event Channels for designer-friendly Inspector wiring.
• AnimationEventManager for turning any animation event into gameplay signals with simple key-to-channel mapping.

This asset is designed to reduce boilerplate, improve scene-to-scene reliability, and keep event logic scalable as your project grows.

Why It’s Useful

• Build features faster with less coupling between gameplay systems.
• Give designers a safer event workflow without writing code for every connection.
• Trigger gameplay directly from animation timing without custom one-off scripts.
• Keep runtime behavior predictable with explicit subscription lifecycle patterns.

Check documentation 

If any questions or problems, write on Discord

Number of textures: 22

Texture dimensions: 2048x2048 and 512x512

Polygon count: 12000 tris

Number of meshes/prefabs: 4 / 20

Rigging: Yes

Animation count: 108

Animation type list: In Place and Root Motion

UV mapping: Yes

LOD information: No

Types of materials: PBR

This asset has CARTOON FOX family models - adult and cub.

The model has 51 bones and 12000 tris.

Texture maps - albedo, AO / metallic / roughness, normal map (all 2048x2048).

Separate model for mobile phones with 3500 triangles.

100+ animations (IP/RM):

Attack (bite, move bite, front, left, right, jump, down), hit (front, back, middle), death (left, right), digging (start, loop, end), idle 1-7, eat, eat tear, drink, lie 1-2, lie belly 1-2, sleep, sleep belly, 15 stages jump (start, start forward, start place, fly up, fly up forward, fly horizontal, fly down high, fly down high forward, fly down low, fly down low forward, land, land forward, land place, fall edge, hooked and climbed), jump (forward, run, place), crouch move (front, left, right, back, back left, back right), crouch (idle 1-2, turn left, turn right), walk (front, left, right, back, back left, back right ), trot (front, left, right), run (front, left, right ), run fast (front, left, right ) swim (enter, front, left, right, back, back left, back right ), turn (left, right), turn 180 (left, right ), sitting (start, end, idle 1-2), scratch ear, etc.

The animator controller is missing.

If you have questions, then write to the mail:

RedDeer3D@gmail.com

● Unity 2021.3+: Compatible with Unity 2021 LTS and above

● No External Dependencies: Self-contained — no third-party packages required from Asset Store

● Dual Backend: LibGit2Sharp for fast local operations + Git CLI for remote operations (fetch, pull, push, stash, LFS)

● Dark & Light Theme: Full support for Unity Pro (dark) and Personal (light) editor skins

● FileSystemWatcher: Auto-detects repository changes and refreshes status automatically

UniGit brings a complete Git workflow directly into the Unity Editor. No more switching between Unity and external Git clients — manage your entire version control workflow from a single editor window.

Core Features:

● Setup Wizard — Guided 4-step setup: Git detection, user info, GitHub OAuth login, and project initialization

● Changes Tab — View modified files, stage/unstage, commit with message templates, and search/filter files

● History Tab — Browse commit history with virtual scrolling, view diffs, cherry-pick commits or individual files

● Pull Requests Tab — View, create, and merge GitHub PRs with reviews and comments, right inside Unity

● Conflict Resolver — Resolve merge conflicts with side-by-side comparison, Accept Ours/Theirs, and CSV cell-level diffing

● 3 Diff View Modes — Unified, Split (side-by-side), and CellSplit (CSV-aware) with inline character-level highlighting

● Branch Management — Create, switch, rename, delete, and merge branches from the toolbar

● Stash Support — Stash all or selected files, apply, pop, and drop with full diff preview

● Project Overlay — Color-coded status indicators on every file and folder in the Project window

● File History — Track the full history of any file with git log --follow

● LFS Support — Track, lock/unlock, push, pull LFS files directly

● Keyboard Shortcuts — Ctrl+C (commit), Ctrl+P (push), Ctrl+Shift+P(pull), Ctrl+R (fetch), Ctrl+F (search), and more

GitHub Integration:

● OAuth Device Flow authentication

● Browse and manage Pull Requests with reviews and comments

● Create repositories and clone from your GitHub account

※ Built for real projects — UniGit was developed and battle-tested in production game development. Every feature exists because we needed it.

• Gettext-first pipeline for Unity (.po/.pot).
• Runtime API:
• HyperPOLocalization.GetString(...)
• HyperPOLocalization.GetStringContext(...)
• HyperPOLocalization.GetPlural(...)
• HyperPOLocalization.GetPluralContext(...)
• Context (msgctxt) and plural (msgid_plural / msgstr[n]) support.
• Selection-based extraction from Unity assets.
• POT generation and update workflow from extracted manifest data.
• Poedit-compatible flows:
• Template-based (Create/Update POT)
• Update from Code with generated Temp/*.php.
• Extraction metadata attributes:
• TranslationComment
• TranslationContext
• TranslationPlural
• DontTranslate
• Project Settings integration for extraction presets, regex rules, and path configuration.
• Diagnostic Console messages with stable IDs (HPO-xxx).
• No required third-party dependencies.
• Includes demo scene and sample language files (demo_en.po, demo_es.po).

Hyper PO Localization is a production-focused Unity localization toolkit built around standard Gettext files (.po, .pot).

With Hyper PO Localization, you can extract translatable content from selected Unity assets, generate/update POT templates, translate in Poedit, and load languages at runtime from StreamingAssets/Languages.

It is battle-tested and actively maintained through real production use in our in-development game (Littlelands) and designed for small-medium indie teams that want a clean workflow without spreadsheet-heavy pipelines or fragile string-ID systems.

✨ Why this workflow works well:

• All text is stored in portable, version-friendly .po/.pot files. a widely used translation format, so many translators can work with it immediately.
• You can send translation files directly to translators without giving Unity project access.
• Non-technical collaborators can create or update translations using familiar tools like Poedit.
• Context (msgctxt) and plural forms (msgid_plural, msgstr[n]) are built into the format.
• You avoid maintaining custom Excel sheets and complex identifier tables for daily translation work.

✨ The package includes editor tools for extraction settings, presets, language paths, and translation status checks, plus a one-click sample installer and bilingual documentation (EN/ES). Included tooling and API:

• Editor workflow for Extract Strings, Create POT, and Update POT.
• Project Settings for extraction presets, regex rules, and path configuration.
• Runtime methods:
• HyperPOLocalization.GetString(...)
• HyperPOLocalization.GetStringContext(...)
• HyperPOLocalization.GetPlural(...)
• HyperPOLocalization.GetPluralContext(...)
• Diagnostic logs with stable IDs (HPO-xxx) for easier support/debugging.
• One-click sample installer and bilingual documentation (EN/ES).

✨ See documentation online