Asset Store newest packages

To go deeper on this package read the offline documentation (PDF file) covering topics like optimization, key parameters and HDRP asset Setup.

Important before buying: The Lighting presets where made exclusively for HDRP and for real-time lights, the offline documentation included in this package talks about combining it with baked lighting, so do not forget to read the tutorial in case you want to dig deeper with the lighting templates of this package!

Package Content:

11 Lighting Presets/templates to drag and drop into your scene as Prefabs

-Each Preset is divided in 3 objects: Directional light (Sun), Render Settings and Post Processing

-These presets/templates cover ilumination like Morning, Sunny day, Cloudy, afternoon and night.

01 Ray tracing preset

03 Samples of Local Fog Volumes to dress your scene

01 Noise Texture(s)

02 HDRI Sky samples

Visit SeedMesh Discord server for support: https://discord.gg/8hU5VfzmPf

Number of textures: 32

Texture dimensions: 4096x4096

Polygon count of : about 7 000 faces each character

Number of meshes/prefabs: 16/16

Rigging: Yes

UV mapping: Yes

Types of materials and texture maps: Color, Normal map

Mixall studio presents a good solution for your games, VR projects and simulators: Homeless - survival characters. A character set of 16 homeless people in old clothes. Perfect for survival projects and top-down simulators.

*The models are single-mesh and may not always be suitable for close-ups; please view screenshots before purchasing.

★ Key Features ★

• 16 homeless people
• Characters are setup to work with Mecanim (no animations included in this pack)
• low poly mesh grid

★ Assets ★

• 16 characters with rig

★ Other Assets ★

Combine this asset pack with our other assets:

- Characters pack - laboratory scientists

- Characters pack - guards and prisoners

- Characters pack - doctors and patients

- Prison - big building, characters and props

- Prison house - restricted area

- Prison cell - interior and props

- Interrogation room - interior and props

- Torture - dungeon and props

- Electronics store devices and furniture

- Coffee shop interior and props

- Grocery store interior and props

- Prison big building, characters and props

- Grocery store interior and props

- Butcher shop cafe, meat freezer and cloakroom

Need support? Write to us: Mixall.team@gmail.com

★ Follow us on social media ★

INSTAGRAM | YOUTUBE | FACEBOOK

ARTSTATION | PINTEREST | DISCORD

The package includes two sample scenes where you'll find all the assets (Built-in and URP)! You can load it or simply select and drag the models from the "Models" folder and add the corresponding material.

A PSX-style prop pack featuring a wide variety of low-poly assets designed for casino environments. Includes small, medium, and large props, ideal for building retro-style interiors.

Contents (120 assets total):

🎲 Main Props

• Slot Machine
• Blackjack Table
• Poker Table
• Roulette Table (2 variations)
• Fortune Wheel
• Simple Safe (non-openable)
• Safe (openable)
• Briefcase (openable, with money)
• Briefcase (openable, empty)
• Simple Briefcase (non-openable)

🖥️ Environment & Props

• Score Display TV
• Hanging Lamp
• Casino Sign
• VIP Sign
• Exit Sign

🚧 Barriers & Furniture

• Stanchions (3 variations)
• Chairs (4 variations)
• Carpets (4 variations)

💵 Money & Gambling Props

• Money Stacks 
• Banknote
• Tokens Tray
• Casino Tokens/Chips (5 variations: Black, Red, Blue, Green, VIP)

🚬 Smoking Props

• Cigarette Pack (open, full)
• Cigarette Pack (open, empty)
• Simple Cigarette Pack (non-openable)
• Cigarette (lit)
• Cigarette (unlit)
• Cigarette Butt
• Lighter (openable)
• Simple Lighter (non-openable)
• Ashtray

🎲 Accessories

• Dice (2 variations)
• Dice Cup

🍾 Drinks

• Whisky Bottle
• Champagne Bottle
• Drink Glasses (2 variations)

🃏 Cards

• Full Deck of Playing Cards (Diamonds, Spades, Clubs, Hearts, Joker)

Modular/Separated Parts:

• Safe Combination Dial
• Safe Valve
• Safe Door
• Cigarette Pack Lid
• Lighter Lid
• Briefcase Lid
• Slot Machine Lever
• Slot Machine Buttons (2)
• Slot Machine Glass
• Fortune Wheel (separate wheel)
• Sign Support / Stand
• All Playing Cards, Tokens and Dice (separated)

Technical Details:

• Total assets: 120
• Average polycount: ~88 triangles per asset
• Total polycount: ~10,589 triangles

Textures:

• 2 Atlas textures for optimization
• Resolution: 1720 x 1080 px each

Texture Maps:

• Albedo only (PSX-style)

The package includes two sample scenes where you'll find all the assets (Built-in and URP)! You can load it or simply select and drag the models from the "Models" folder and add the corresponding material. Also includes the alpha setting to give the small fan the correct transparency.

A PSX-style prop pack featuring a variety of low-poly assets designed for subway/metro environments. Includes small, medium, and large props ideal for building retro-style stations.

Contents (51 assets total):

• Fans (3 variations)
• Seats (2 variations)
• Platform doors (2 variations)
• Turnstiles
• Ticket booths (2 variations)
• Speakers (2 variations)
• Security camera
• Pipes (2 variations)
• Fences (3 variations)
• Exit signs (6 variations) and sign stands (2 variations)
• Vending machines (2 variations)
• Ticket machines (2 variations)
• Light fixture
• Extras: cone, trash can, wet floor sign

Modular/Separated Parts:

• Platform doors (separate elements)
• Turnstiles
• Sign stands
• Fan (head, blades, support)

Technical Details:

• Total assets: 51
• Average polycount: ~100 triangles per asset
• Total polycount: ~5,100 triangles

Textures:

• 2 Atlas textures for optimization
• Resolution: 1720 x 1080 px each

Texture Maps:

• Albedo only (PSX-style)

Features

Modular gameplay systems, auto-combat, abilities, upgrades, enemy AI, wave system, loot system, data-driven configs, object pooling

Supported Platforms

PC, Android, iOS

Supported OS

Windows, macOS, Android, iOS

Documentation

Available online (link provided with the asset package)

Survivor Game Core is a modular gameplay framework for Unity, designed to help you build Vampire Survivors–style games faster and with clean, scalable architecture.

It provides a high-performance, system-driven foundation for combat, enemies, weapons, upgrades, and progression—so you can focus on gameplay design instead of low-level implementation.

Built with a data-driven approach, the framework allows you to configure almost everything via ScriptableObjects while maintaining excellent runtime performance (supporting up to ~1000 enemies simultaneously).

Perfect for indie developers and teams who want to create survivor-like games without reinventing core systems from scratch.

💬 Survivor Game Core – Core Contents

⚔️ Modular Combat & Weapon System

A fully configurable weapon system built around:

• Shooting patterns (single, burst, nova, spread, custom)
• Projectile behavior (speed, lifetime, pierce, radius)
• Impacts, effects, and modifiers

Create new weapons entirely via configs or extend behavior through code.

👾 High-Performance Enemy System

Optimized enemy architecture designed for large-scale gameplay:

• Supports hundreds to 1000+ enemies
• Spatial grid-based movement
• Separation system (no clumping)
• Smooth and natural swarm behavior

Includes:

• Movement, attack, health, effects systems
• Wave-based spawning
• Positioning and difficulty control

📈 Upgrade Graph System

Flexible graph-based upgrade system:

• Add weapons, upgrade levels, or apply modifiers
• Conditional availability (based on player state)
• Weighted random selection
• Fully data-driven

Supports complex progression trees similar to roguelike systems.

🌊 Wave-Based Level System

Create dynamic levels using:

• Timed waves
• Enemy spawn configurations
• Spawn rate curves
• Difficulty scaling

Supports:

• Linear progression
• Endless survival modes
• Custom pacing

🧠 System-Driven Architecture

The framework is built around:

• Independent systems (movement, combat, spawning, etc.)
• Controllers for orchestration
• Lightweight runtime data (struct-based)

Benefits:

• High performance
• Clean separation of concerns
• Easy extensibility

🎨 Fantasy UI Included

The asset includes a fantasy-themed UI pack used in demo scenes:

• Main menu
• HUD elements
• Upgrade selection UI

UI is fully optional and can be replaced with your own.

🎮 Best Fit For

This framework is ideal for projects where scalable combat and fast iteration matter:

✅ Vampire Survivors–like games
✅ Roguelike / Roguelite shooters
✅ Auto-battlers
✅ Arena survival games
✅ Bullet-heaven gameplay
✅ Prototype-heavy projects
✅ Indie & commercial productions

⭐ Why Choose Survivor Game Core?

Because it gives you a production-ready gameplay foundation instead of just examples.

• No need to build core systems from scratch
• Designed for performance and scalability
• Fully modular and extensible
• Data-driven workflow for fast iteration
• Clean architecture suitable for long-term projects

Less engine work — more game design.

🧩 Integrates Great With These Workflows

Designed to fit seamlessly into modern Unity pipelines:

🔹 Custom architectures – plug systems into your existing project
🔹 Dependency Injection – built-in DI or replace with Zenject
🔹 ScriptableObject workflows – fully data-driven setup
🔹 Mobile + PC – optimized for different performance targets
🔹 Prototype → Production – scales with your project

⚙️ Dependencies

• UniTask – async operations
• TextMeshPro – used for UI/visualization only

🚀 Quick Start

1. Import the asset
2. Install UniTask
3. Open: Scene_Demo_MainMenu
4. Select a level → gameplay starts in: Scene_Demo_Gameplay

🔗 Additional Resources

🌐 Website

💬 Discord

Number of textures : 27

Number of Materials : 5

Texture dimensions : 4K

Vertices count : 25950 Vertices

Number of meshes/prefabs : 1 Mesh/ 1 Prefab

Rigging: Yes

UV mapping: Yes

Types of materials and texture maps : PBR

This Chef Vendor Robot NPC is designed for food stalls, market kitchens, and sci-fi street food environments. The robot combines a humanoid torso with a built-in cooking module, serving trays, and embedded tools, making it ideal as a food vendor or kitchen worker NPC.

It features a mechanical chef hat, decorative side ornaments, a cloth apron, robotic arms, and worn rusted metal plating.

The character uses a custom generic rig, allowing for robotic movement instead of humanoid retargeting.

The model comes with a single rusty orange PBR texture set, and the mesh is separated into head, torso, servers, arms, and tray components.

Features:

• Custom generic robotic rig (non-humanoid)
• One rusted PBR texture set
• BaseColor, Normal, Metallic, Roughness maps
• Cooking station, trays, pots, and serving accessories built into mesh
• Separated mesh components
• Works in Unity, Unreal, VR, AR
• Ideal for restaurant stalls, food vendors, bazaars, or cinematic scenes

For more vendor bots or a complete NPC lineup, check the Vendor NPC Robots Pack or the Full NPC Collection.

Features

• Advanced spline authoring with multiple curve types
• Supports true clothoids / Euler spirals for road and track style transitions
• Frame-aware track design with roll, banking, and orientation controls
• Adaptive spline sampling and curve/frame preview workflows
• Mesh extrusion modes: Road, Pipe, UTrack, and Custom profile
• Prefab spawning along splines with spacing, offsets, roll offset, pooling, and even distribution
• Optional surface snapping and cached deformed path support
• Editor tooling for per-sample track data: curvature, torsion, g-forces, and more.
• Includes sample scenes, local README, and full online documentation

Supported OS

• Windows 10/11

Documentation

• https://gregpritchard.net/trackflowpro-docs/index.html

Dependencies

• None external

TrackFlow Pro is the most powerful spline authoring and generation toolkit for Unity. It is designed for path-driven content such as roads, race tracks, coaster paths, rails, pipes, conveyors, tunnels, cables, and other procedural route-based systems. It shines especially when designing systems that need real world considerations, like driver comfort on a race track, or the g-forces felt by passengers on a roller coaster. All of this is standard out of the box with TrackFlow Pro.

Create curves with more than a basic spline workflow: TrackFlow Pro supports advanced curve generation including clothoids/Euler spirals for smoother track and road transitions, plus standard spline tools such as frame-aware editing for roll, banking, and orientation control. You can then use the built-in spawner workflow to either extrude meshes along the spline or distribute prefabs along it.

Author curves with a mix of interpolated and extrapolated segments, unleashing the power of pure clothoids as a design tool.

This release (ver 7) includes network ready updated models and scripts for Logic Blox versions including: Logic Blox Primitives, Logic Blox Vintage, Logic Blox Synth and Logic Blox 5 Deluxe. Can be applied overtop of previous Logic Blox packages with Uniity editor ver 2022 or greater

Automatically works with New or Both input system. Props will intewract in both standalone or netwoked envronment (using netcode)

URP is derfault shader but can be changed. (limited HDRP compoatability)

New features include:

• Over 150 premade props
• Includes all updated models from Logic Blox Deluxe
• Reduced materials
• Embedded Netcode for GameObjects
• New advanced models and effects
• Targeting/faction module to turn objects into battle bots
• Character controller framework for drop in animation models

• Built on Unity CharacterController
• Modular movement architecture
• Smart step obstacle traversal
• First-person and third-person support
• Camera collision handling
• Audio integration
• Input System integration
• Animation-agnostic design
• Extensible movement states
• Full source code included
• Unity 2022.3 LTS or newer
• Compatible with Unity 6
• New Input System required
• No Rigidbody dependency
• Example demo scene included
• Inspector-ready configuration

Demo Itch(WebGL): itch.io

Smart Step Craft Character Controller

Smooth stair climbing and stable movement for voxel and sandbox projects using Unity CharacterController.

Smart Step Craft Character Controller is a professional modular first/third-person controller built for developers who need production-ready movement without Rigidbody complexity.

Designed for voxel, sandbox, survival, and exploration projects, the system uses Unity’s built-in CharacterController to provide predictable movement, smooth stair traversal, and clean extensibility.

Core Movement Features

• Smooth step climbing up to 1 meter obstacles without jump input.
• Walk, sprint, sneak, jump, and fall
• Smart step movement for stairs and obstacles
• Stable ground movement with configurable speeds
• Air control with sprint boost mechanics
• Auto-jump support for obstacle traversal
• CharacterController collision fix for velocity spikes

Camera System

• First-person view
• Third-person rear view
• Third-person front view
• Camera collision prevention using spherecast
• Adjustable zoom distance
• Independent pitch limits per perspective
• Optional view bobbing

Animation Friendly

No animations are included.

No animator controller is required.

Smart Step Craft Character Controller is designed for developers who already have their own animation workflow.

It provides clean movement data for any animation system:

• movement state
• grounded state
• current speed
• vertical velocity
• movement direction

Compatible with:

• Unity Animator
• custom animation systems
• third-party animation assets

Extensible Architecture

The controller follows a modular design that allows new movement systems to be added without modifying core logic.

Easily extensible for:

• swimming systems
• flying systems
• ladders
• parkour mechanics
• custom movement states

using independent modules.

Included Systems

• CraftPlayerController
• CraftMovementEngine
• CraftCameraSystem
• PlayerInputHandler
• CharacterControllerFix
• CraftAudioController
• FirstPersonBodyHider

Audio Features

• Dynamic footsteps based on movement speed
• Jump sound
• Landing sound
• Volume adjustment by movement type

Ideal For

• voxel games
• sandbox games
• survival games
• first-person projects
• third-person projects
• custom animation pipelines

Included Content

• Full source code
• Example scene
• Input actions asset
• Technical documentation

Environment System is a lightweight and practical solution for adding time-of-day and weather control to your project.

It includes a configurable day/night cycle, weather presets, skybox switching, optional storm lightning, and simple demo tools for quick testing. The system is designed to stay easy to set up, easy to extend, and safe to use in both prototype and production-style scenes.

The core module works as a standalone system. For Game Creator 2 users, the package also supports optional visual scripting integration through dedicated instructions, conditions, and triggers.

Features

• Day/night cycle with automatic time progression

• Configurable sunrise and sunset timing

• Sun and moon visual support

• Day and night skybox support

• Smooth skybox transitions

• Optional skybox rotation

• Weather presets for fog, ambient color, audio, VFX, and lighting

• Random weather support

• Storm lightning controller with thunder audio and effects

• Demo scene setup helper

• Simple demo UI for weather and time testing

• Optional Game Creator 2 integration

Included Game Creator 2 Integration

• Instructions for time, weather, random weather, sunrise, sunset, and day length

• Conditions for day, night, dawn, dusk, weather checks, and time comparisons

• Triggers for weather changes, time changes, sunrise, sunset, day start, and night start

Use Cases

• Survival games

• Open world scenes

• Stylized prototype environments

• Adventure games

• Simulation projects

• Game Creator 2 workflows

Notes

• Works as a standalone module

• Game Creator 2 integration is optional

• Compatible with built-in, URP, and HDRP projects with scene-specific visual setup

I am open to suggestions, if you have any questions or have found a bug - please write to assetsupport@ispcode.com and I will try to answer you as soon as possible.

Online documentation and info are here: https://9476764.gitbook.io/assets/environment-system-compatible-with-game-creator-2

Provided Prefabs:

• Slingshot (1)
• Ammo (1)

Provided Sprites:

• Slingshot (6)
• Ammo (4)

Provided Audio

• Throw Sounds (2)

Simple Slingshot System provides a simple slingshot prefab with several properties that can be easily modified in the Unity editor, like drag radius, reload time, and shoot speed. Just drag the slingshot prefab into your scene, press play, and start shooting!

This asset provides several sprites and prefabs for both the slingshot and ammo balls, but you can also easily bring in your own art assets to modify how things look. 

Documentation is included and code is heavily commented to help you understand how the slingshot works. A demo scene is included. 

Unity Version Compatibility Unity 2021.3 LTS through Unity 6.x. Version-specific API differences are handled via conditional compilation directives in the relevant source files.

Render Pipeline Compatibility Compatible with Built-in Render Pipeline, Universal Render Pipeline (URP), and High Definition Render Pipeline (HDRP). Runtime Atlas does not inject any render passes and reads renderer data through standard Unity APIs only.

Runtime Impact in Builds None. All editor-side code is wrapped in #if UNITY_EDITOR guards and compiled exclusively into the editor assembly. The RuntimeAtlas.Core runtime assembly contains only the AlertEntry data type and demo behaviours — no monitoring logic runs in player builds.

Assembly Structure

AssemblyTypeContentsRuntimeAtlas.CoreRuntimeAlertEntry data type; no editor dependenciesRuntimeAtlas.Core.DemoRuntime (Demo)Demo scene behaviours; input compatibility layerRuntimeAtlas.EditorEditor onlyAll 18 diagnostic modules and the main AtlasWindow

Input System CompatibilityRuntime Atlas core does not require any specific input backend. The optional demo scene uses conditional compilation to support both the legacy Input Manager and the new Input System package, whichever is present in the project.

DependenciesNo third-party packages required. All functionality uses built-in Unity Editor and Engine APIs only.

Namespace

• Runtime: Arish.RA
• Editor: Arish.RA.Editor

Source CodeFull C# source code is included. No DLLs, no obfuscation.

UI SystemIMGUI-based editor window. Dockable in the standard Unity Editor layout.

DOCUMENTATION

Runtime Atlas ships with a documentation set inside Assets/RuntimeAtlas/Documentation/:

• README.md — Project overview, Unity compatibility, how to open the window, and a documentation index.
• INSTALL.md — Step-by-step installation instructions, assembly definition validation checklist, optional demo scene setup, and troubleshooting guidance for compile errors and layout resets.
• QUICK_START.md — Minimal guide covering how to open the window, what to check first in Play mode, how to review core tabs, and how to export a report. Intended for developers who want to get oriented in under five minutes.
• FEATURES.md — Full feature reference covering all 18 diagnostic tabs, performance and alerting systems, reporting pipeline formats, and compatibility notes.
• CHANGELOG.md — Version history with added features, changes, bug fixes, and known issues for each release.

Note:

Complete documentation is included inside the package under:

Assets/RuntimeAtlas/Documentation/

All documentation files are plain Markdown and can be read inside Unity or in any text editor.

SUPPORT

Need help with Runtime Atlas?

Support Email: toolsstudio@zohomail.in

Community Discord: https://discord.gg/nFMruVyC

Typical response time for support emails is 1–3 business days. Bug reports are most helpful when they include:

• Unity version

• Render pipeline (Built-in / URP / HDRP)

• Steps to reproduce the issue

• Console logs or screenshots

Owerview

Keeping tabs on multiple runtime systems during Play mode typically means juggling several native Unity windows — the Profiler, the Console, the Inspector, the Audio Mixer, and so on. Runtime Atlas consolidates that monitoring into one place. Open it once (Window > Runtime Atlas > Open or Ctrl+Alt+R), dock it where you want it, and it stays live for the duration of your session.

The tool is structured around two rows of tabs. The first row covers the systems that tend to matter most during active runtime testing — cameras, audio, the live object graph, timeline recording, alerts, performance, and physics. The second row provides supporting diagnostics: script scanning, optimizer suggestions, a script browser, a component inspector, animator monitoring, audio mixer controls, a scene overview, report generation, a scoped console view, and material inspection.

All editor code is guarded behind #if UNITY_EDITOR and compiled only into the editor-side assembly, so there is no runtime overhead in builds.

Key Capabilities

Runtime Diagnostics The Camera, Audio, Physics, Animator, and Material tabs each poll their respective Unity systems during Play mode and display a live snapshot in the panel. Camera state includes FOV, near/far planes, and rendering path. The Audio tab shows listener status, active AudioSource components, and their spatial settings. Physics inspection covers all Rigidbodies and Colliders in the scene — velocity, sleep state, mass, drag, collider type, layer assignment, and whether the collider is a trigger. The Animator tab surfaces every Animator component in the scene with its current state, layer weights, and writable parameters.

Performance Profiler The built-in profiler samples frame time (ms), FPS, GC allocation deltas, draw calls, triangle count, vertex count, and SetPass calls. Data is stored in a pre-allocated ring buffer with zero heap allocation per sample in the hot path. The panel plots trends over the session so you can spot frame spikes or GC pressure without switching windows.

Timeline Recorder A circular frame-data recorder that captures per-frame snapshots — timestamp, camera FOV, peak audio volume, and related counters — with zero heap allocation during recording. The Timeline Playback UI lets you step through the recorded session after the fact.

Alert System Alerts are aggregated by group and filtered by severity: Info, Warning, and Critical. The panel shows duplicate counts rather than repeating identical entries, which keeps the list readable during busy scenes. Dismissed alerts can be shown or hidden independently.

Script Scanner and Optimizer The Script Scanner inspects your project's C# scripts for common issues: empty Unity lifecycle methods, hot-path anti-patterns such as GetComponent in Update, and missing null checks. Findings are listed with file paths and line numbers. The Optimizer Suggestions panel pairs with the scanner to surface actionable recommendations based on what was found.

Audio Mixer Panel A standalone mixer diagnostics view with live level meters, exposed parameter controls, and snapshot management — useful for debugging dynamic mixer states that are hard to see through the standard Audio Mixer window during runtime.

Scene Overview Live counts of every significant object type in the loaded scene — renderers, lights, colliders, scripts — with a search field and quick-select navigation so you can jump to any object from the panel.

Report Generator Compiles data gathered during the session — timeline recordings, alerts, scanner results — into an exportable report. Supported formats are JSON, HTML, Markdown, CSV, and DOCX. This is useful for sharing diagnostic sessions with other team members or keeping a record of a build review.

Console Mirror A scoped console view that captures log messages tagged by Runtime Atlas, keeping them separate from the main Unity Console. Useful when you want to monitor tool output without the main Console being flooded by project-level logs.

Material Inspector Scans all Renderer components in the scene and exposes each material's shader name and all editable shader properties — floats, integers, colors, textures, and vectors — with live editing support. An object pool pattern eliminates per-frame heap allocation.

Workflow Benefits -

Runtime Atlas is most useful in the middle phases of development, when systems are mostly working but you need to correlate behavior across several subsystems at once. Having camera state, audio routing, physics activity, and performance data in one window reduces the back-and-forth of opening and closing multiple native editors. The export pipeline makes it easy to hand off diagnostic sessions to other developers without describing everything verbally.

Render Pipeline Compatibility

Runtime Atlas is an Editor extension — it does not inject render passes or modify rendering behavior. It reads renderer and shader data through standard Unity APIs and works with the Built-in Render Pipeline, URP, and HDRP without modification.

Use Cases

• Debugging camera rig behaviour during cutscenes while monitoring FOV and near-plane settings live
• Correlating audio source counts and mixer state with frame time spikes
• Checking rigidbody sleep states and collision layer assignments at runtime without pausing
• Running a script scan before a milestone submission to catch empty lifecycle methods left in from early prototyping
• Generating a diagnostic report after a QA session to share with the rest of the team
• Monitoring GC allocation trends over a Play Mode session to identify sources of per-frame pressure

KEY FEATURES

• Camera Inspector — Live camera state per camera in scene: FOV, clipping planes, rendering path, projection mode, and viewport rect. Updates in real time during Play mode.
• Audio Inspector — Monitors the active AudioListener and all AudioSource components: clip name, volume, pitch, spatial blend, and play state. Separate from the Audio Mixer panel.
• Audio Mixer Panel — Dedicated view for AudioMixer diagnostics with live level meters, exposed parameter controls, and session snapshot management.
• Physics Inspector — Scans all Rigidbodies and Colliders each frame. Surfaces velocity, angular velocity, sleep state, mass, drag, collider type, layer, and trigger flags. Also reads the Physics Layer Collision Matrix. Zero heap allocation on poll via pre-allocated lists.
• Performance Profiler — Samples frame time (ms), FPS, GC allocation delta, draw calls, triangle count, vertex count, and SetPass calls into a circular ring buffer with no per-sample heap allocation. Displays trend plots directly in the panel.
• Timeline Recorder — Records per-frame runtime snapshots into a zero-allocation circular buffer during Play mode. The Timeline Playback UI provides scrubbing and step-through after recording.
• Alert System — Aggregates alerts by group with Info / Warning / Critical severity levels. Deduplicates repeated alerts by count rather than flooding the list. Supports independent filtering and dismiss controls.
• Script Scanner — Statically analyses C# scripts in the project for empty lifecycle methods, hot-path anti-patterns (GetComponent in Update, foreach in tight loops), and missing null checks. Scan is manually triggered; never runs per-frame.
• Optimizer Suggestions — Paired with the Script Scanner. Presents actionable recommendations based on scan findings, grouped by issue type.
• Script Viewer — Browses and displays project scripts with virtualized visible-line rendering for performance on large files.
• Component Inspector — Inspect any GameObject's component list and serialized fields without using the standard Inspector. Useful when you want to watch specific component data while the main Inspector is locked to another object.
• Animator Monitor — Lists every Animator in the scene with its current state name, normalized time, layer weights, and all parameters. Parameters can be edited live from the panel.
• Scene Overview — Live aggregate counts of renderers, lights, colliders, and scripts in the active scene. Search field with quick-select navigation to jump to any matching object in the Hierarchy.
• Material Inspector — Polls all Renderer components and exposes each material's shader name and all shader properties (float, int, color, texture, vector) for live editing. Uses an object pool to avoid per-frame allocation.
• Console Mirror — Ring-buffer log capture scoped to Runtime Atlas internal messages. Keeps Runtime Atlas output separate from the main Unity Console to reduce noise.
• Report Generator — Compiles session data into exportable reports. Supported export formats: JSON, HTML, Markdown, CSV, and DOCX.
• Graph Visualizer — Live node-link diagram showing runtime object relationships in the scene. Useful for visualising dependency graphs and reference chains at runtime.
• About Tab — In-package documentation index, version info, and publisher details accessible directly from the tool window.

Number of textures: 2

Texture dimensions: 16x16

Minimum polygon count: 6

Maximum polygon count 685

Number of meshes/prefabs: 89/89

Colliders already configured on all meshes for immediate use

Rigging: No

Types of materials and texture maps (e.g., PBR): png

I am sharing my personal interpretation of a recreational sector – a place where, in my retro-futuristic vision, space station crews gather to rest and recharge. This is more than a collection of low-poly assets; it is a carefully considered space designed to evoke a sense of scale and technological craftsmanship.

Key Features of the Crew Lounge:

• 71 Original Props: Includes arcade machines, pool and foosball tables, jukeboxes, lounge seating, and entertainment consoles, all harmonizing with the Cosmic Retro aesthetic.
• 18 Modular Structures: Simple, versatile walls, floors, and doorways included to enhance project immersion and allow for seamless environment building.
• Ready-to-Use Demo: The package includes a pre-assembled URP demo scene, showcasing a fully realized lounge layout to jumpstart your project.
• Technical Craftsmanship: Clean topology and custom pivots for an effortless creative workflow.
• Optimized Design: A single minimalist material with 16×16 textures, fully compatible with URP and Built-in pipelines. Developed and tested in Unity 6.

Experience a fragment of the Recreation Room (Free Demo):

• Recreation Room Demo

Test the Quality:

Explore the craftsmanship of individual modules with these free samples:

- Hangar Sector / Hangar Demo

- Command Center / Station Demo

- Social Zone / Mess Demo

- Research Sector / Laboratory Demo

- Living Quarters / Bedroom Demo

Expanded Universe (Collections):

- Core Duo – A focused set featuring the Station and Mess modules

- Expanded Colony – A broader 3-module vision including Station, Mess, and Laboratory

- Grand Colony Collection – The ultimate 5-module system: Station, Mess Hall, Laboratory, Hangar, and Bedroom

Perfect For:

• First-person and third-person sci-fi exploration games.
• Top-down & isometric base-building projects.
• Social areas in survival or simulation games.

💛 Enjoyed the asset? Leaving a short review helps me a lot as a solo creator!

Features:

• Comprehensive Scene Export: Exports static meshes, skeletal meshes, landscapes, foliage, materials, lights, cameras, animations, and splines, reconstructing them with the correct scene hierarchy.
• Deep Unity Integration: Supports Universal Render Pipeline (URP), High Definition Render Pipeline (HDRP), and the Built-in Render Pipeline.
• Native Godot Support: Seamlessly exports to Godot 4.x and Godot 3.x.
• Automated Coordinate Conversion: Automatically converts Unreal Engine's left-handed Z-up coordinate system to Unity and Godot's Y-up systems.
• Landscape & Terrain Rebuilding: Exports landscape heightmaps with accurate height ranges.

Code Modules:

• Name": "CrossEngineOptimizer","Type": "Runtime"
• "Name": "CrossEngineOptimizerEditor","Type": "Editor"

Number of Blueprints:0

Number of C++ Classes:89

Network Replicated: No

Supported Development Platforms:

• Windows: Yes
• Mac: No

Supported Target Build Platforms: Windows

Supported:

Unreal Engine: 5.1, 5.2, 5.3, 5.4, 5.5, 5.6, 5.7

Unity: 2022 LTS or later / High Definition Render Pipeline (HDRP), Universal Render Pipeline (URP), Built-in Render Pipeline

Godot: Godot 3.x (GDScript), Godot 4.x (GDScript)

Documentation Link: https://docs.google.com/document/d/17SqF1_qestYsDg1QOpMp0yfoZ-8G3_4L/edit?usp=sharing&ouid=102135913982536213071&rtpof=true&sd=true

🚀 CrossEngineOptimizer (CEO) v0.8 OpenBeta

"For the unexpected pivots. Every Creator Needs a CEO."

CrossEngineOptimizer (CEO) is an advanced Unreal Engine 5 editor plugin developed by Leartes Studios that automates the transfer of complete scenes from Unreal Engine directly to Unity and Godot.

Say goodbye to the tedious, manual process of migrating assets, fixing coordinates, and rebuilding materials. The CEO handles the full conversion pipeline: geometry, textures, materials, transforms, landscape data, foliage, cameras, and lights. It writes all data to a structured folder that can be opened directly as a Unity or Godot project, saving you countless hours of manual labor.

macOS compatibility is currently in progress and will be available in an upcoming release.

🔥 Why Choose CEO? (Not Just Migration. Optimization.)

• The Ultimate Engine-Agnostic Hub: Export to Unity (URP, HDRP, Built-in) and Godot (3.x, 4.x) from a single, unified interface. Why choose a side when the CEO gives you both?
• Nanite Fallback Optimization: Don't crash target engines with millions of polygons. The CEO seamlessly extracts coarse or fallback LODs from your Nanite meshes for perfect performance.
• Performance-Preserving Foliage: Mirrors Unreal Engine's InstancedFoliageActor by placing foliage as GPU-instanced groups in the target engine. Keep the dense forests, lose the lag.
• True Landscape Generation: Instead of exporting a useless static mesh, CEO exports precise heightmaps and automatically reconstructs them as editable Terrain in Unity or Godot.
• Automated Coordinate Conversion: Flawlessly converts Unreal Engine's left-handed Z-up system to Unity/Godot's Y-up system. Skeletons, animations, and camera rotations work perfectly out of the box.
• Smart Material & Render Pipeline Mapping: Automatically translates PBR parameters and creates native material assets tailored to your chosen render pipeline (URP/HDRP/Standard).

🎯 Who is the CEO for?

For Asset Creators: Multiply your marketplace revenue. Build your environment once in Unreal, and let the CEO package it for Unity and Godot marketplaces in minutes.

For Indie Devs: Save weeks of manual labor. Focus on creating your game instead of entering data.

For Studios: Future-proof your pipeline. Engine plans change unexpectedly. Protect your studio against "engine lock-in" and unexpected pivots.

🚀Review Roadmap: What’s Next? The price will increase with each update

We update our tool based on your reviews and requests. Here is our flight plan:

[Milestone 05] - Project Cleaner: Auto-prune unused assets for lighter exports.

[Milestone 10] - Material Baking: Support for complex Multi-Layered Materials.

[Milestone 15] - Live Preview: Quick snapshot of your scene in the target engine.

[Milestone 20] - World Partition: Full support for massive Open-World scenes.

[Milestone 25] - Cinematic Bridge: Exporting Sequencer data to Unity Timeline.

Documentation List :

• Read Me
• Quick Start
• Complete User Guide
• FAQs
• installation guide

DISCLAIMER:

The following plugins need to be enabled for product functionality.

GeometryScripting - Enabled

GeometryProcessing - Enabled

MeshModelingToolset - Enabled

MeshModelingToolsetExp - Enabled

For all your promotional requests, technical support needs, suggestions, and refund requests, please create a ticket.

Here, you can join the Leartes Discord channel for live support, discounts, and Custom Outsource Environment Projects.

INSTAGRAM | FACEBOOK | LINKEDIN | X | YOUTUBE | REDDIT

Show less

Number of textures - 24

Texture dimensions - 4086x4086

Polygon count of [Zombie - Hazmat ] - 38,115

Minimum polygon count - N/A

Maximum polygon count - N/A

Number of meshes/prefabs - 3/3

Rigging: Yes

Animation count - Root motion x26 , In place x26

Animation type list - Idle x3, Walk x3 ,Crawl x2 ,Attack x5 ,Chases x4 ,Stand/Reach/Turns x9.

UV mapping: Yes

LOD information (count, number of levels) - No LODs

Types of materials and texture maps - HDRP , URP

Features:

• Game-Ready: Clean topology and optimized for real-time performance.
• Fully Rigged: Animation-ready, compatible with standard humanoid animations.
• High-Quality PBR Textures: Detailed materials that bring the contaminated suit and decaying flesh to life.
• Perfect For: Survival horror games, VR experiences, and cinematic sequences.

Note: Preview images and promotional renders are created using external software

The asset is optimized for Unity and includes materials compatible with URP/HDRP. Lighting and post-processing in Unity may differ from promotional images.

Number of textures - 32

Texture dimensions - 4086x4086

Polygon count of [Zombie - Police] - 27,255

Minimum polygon count - N/A

Maximum polygon count - N/A

Number of meshes/prefabs - 3/3

Rigging: Yes

Animation count - Root motion x26 , In place x26 

Animation type list - Idle x3, Walk x3 ,Crawl x2 ,Attack x5 ,Chases x4 ,Stand/Reach/Turns x9.

UV mapping: Yes

LOD information (count, number of levels) - No LODs

Types of materials and texture maps - HDRP , URP

Features:

• Game-Ready: Clean topology and optimized for real-time performance..
• Fully Rigged: Animation-ready, compatible with standard humanoid animations.
• High-Quality PBR Textures: Realistic uniform and skin details.
• Perfect For: Open-world survival games, FPS, and zombie-themed cinematics.

Note: Preview images and promotional renders are created using external software

The asset is optimized for Unity and includes materials compatible with URP/HDRP. Lighting and post-processing in Unity may differ from promotional images.

Number of textures - 30 

Texture dimensions - 4086x4086

Polygon count of [Zombie - Soldier] - 36,732

Minimum polygon count - N/A

Maximum polygon count - N/A

Number of meshes/prefabs - 55/55

Rigging: Yes

Animation count - Root motion x26 , In place x26 

Animation type list - Idle x3, Walk x3 ,Crawl x2 ,Attack x5 ,Chases x4 ,Stand/Reach/Turns x9.

UV mapping: Yes

LOD information (count, number of levels) - No LODs

Types of materials and texture maps - HDRP , URP

It’s possible to generate thousands of unique zombies, randomizing their outfits on spawn, and using Master Pose optimizations Unreal has included for modular skeletal characters to render the characters as a single skeletal mesh.

You have full control over what variations are allowed to spawn.

Features:

• Game-Ready: Clean topology and optimized for real-time performance..
• Fully Rigged: Animation-ready,compatible with standard humanoid animations.
• High-Quality PBR Textures: Chillingly detailed torn fabric, and characteristics.
• Perfect For: Supernatural games, and dark fantasy settings.

Note: Preview images and promotional renders are created using external software

The asset is optimized for Unity and includes materials compatible with URP/HDRP. Lighting and post-processing in Unity may differ from promotional images.

• Core Engine: Based on Graphics.RenderMeshInstanced(), rendering up to 1023 instances in a single draw call.
• Spatial Grid System: Minimizes CPU overhead by partitioning the scene into spatial cells.
• Temporal Coherence: Saves CPU cycles by halting repetitive scanning of non-visible cells.
• Shadow Optimization: Distance-based shadow culling and Shadow Proxy support.
• LOD Integration: Fully compatible with Unity's built-in LODGroup system.
• Stabilization: Anti-pop-in systems utilizing v1 Frustum Padding and Distance Hysteresis.
• Requirements: Requires Unity 2022.3 LTS+ and the Burst/Collections/Mathematics packages.

2NGAMES GPU Instancer is a professional-grade optimization solution designed to bring your Unity projects to life, even in scenes containing thousands of objects. Unlike traditional rendering methods, this system automatically scans your scene at runtime and renders everything efficiently on the GPU, reducing CPU overhead by up to 40%.

Why Choose 2NGAMES?It is more than just a simple instancer. With v1 stability features like Frustum Padding and Distance Hysteresis, it completely eliminates object "popping" and flickering at distance boundaries. Whether you are building a dense forest or a crowded city, the "One-Click Setup" allows you to achieve massive FPS gains in seconds.

Key Benefits:

• Extreme Performance: Up to 75% FPS boost in dense, object-heavy scenes.
• Automatic Adaptation: Instantly detects URP or HDRP and optimizes rendering settings accordingly.
• Advanced Culling: Combined Frustum, Distance, and Temporal culling ensure only what’s visible is rendered.
• Stability First: v1 features prevent edge flickering and pop-ins during fast camera movements.

The bundle contains five Unity editor utilities focused on build quality, validation, and regression prevention.

Third Party Notices Generator

• Scans project directories for third-party libraries and license files
• Generates clean THIRD_PARTY_NOTICES and credits documentation
• Supports manual overrides for unknown licenses
• Exports structured compliance files for release builds

Build Size Guard

• Captures build snapshots automatically after builds
• Compares current builds against a saved baseline
• Shows size growth, reductions, and new contributors
• Supports configurable budgets for total build size and growth limits
• Includes CLI and CI integration with structured report exports

Shader Variant Regression Guard

• Parses Unity build logs to capture shader variant counts
• Stores deterministic snapshots for comparison across builds
• Displays total changes and top shader regressions
• Supports limits on total variants and variant growth
• Provides CI checks to fail builds when limits are exceeded

Import Settings Validator & Fix

• Enforces import settings rules for textures, audio, and models
• Supports rule-based validation using path and importer filters
• Displays non-compliant assets in a structured list
• Allows per-asset fixes or bulk fixes
• Includes exportable reports and dry-run validation

Serialization Migration Tool

• Audits serialized field migrations and rename mappings
• Detects missing migration attributes and potential refactor risks
• Scans serialized assets to measure migration coverage
• Supports safe reserialization workflows with previews and backups
• Provides cleanup validation to ensure migrations are fully complete

📜 Docs

Build Quality Suite is a focused bundle of 5 Unity editor tools designed to prevent common production problems before they reach your build.

Instead of discovering issues late in development, this suite helps you detect, enforce, and fix quality problems early across build size, shader variants, asset imports, compliance, and serialization refactors.

These tools are designed for real Unity development workflows where small regressions quietly accumulate and suddenly become expensive.

What’s included

Third Party Notices Generator

Generate clean third-party license notices and credits from your project automatically, helping you stay compliant when shipping your game.

Build Size Guard

Track build size over time, compare snapshots, detect growth, and enforce size budgets before releases.

Shader Variant Regression Guard

Monitor shader variant counts and stop variant explosions before they slow builds or bloat memory.

Import Settings Validator & Fix

Automatically validate and enforce correct import settings for textures, audio, and models across your entire project.

Serialization Migration Tool

Safely refactor serialized fields with migration auditing, coverage scanning, and guided reserialization workflows.

Why this bundle exists

Many Unity issues only become obvious after weeks or months of development:

• Builds suddenly grow hundreds of megabytes
• Shader variants explode and slow compilation
• Import settings drift across hundreds of assets
• Serialization refactors silently break data
• Third-party license notices are missing before release

Fixing these late is frustrating and time-consuming.

Build Quality Suite helps you catch these problems earlier with clear analysis tools, validation systems, and guardrails that keep projects healthy as they grow.

Who this bundle is for

• Solo developers shipping real projects
• Small teams that want lightweight build discipline
• Projects that value stability, predictable builds, and safe refactoring

Why the bundle is worth it

A single regression can easily cost hours of investigation and cleanup.

These tools are built to reduce hidden technical debt by making quality problems visible and enforceable throughout development.

Core Features

• Dynamic Building Generation – Create buildings with customizable walls, roofs, and stairs.
• Modular Building Elements – Easily place and randomize windows, doors, decorations, and other elements.
• Empty Wall Spaces – Define gaps for doors, windows, or unique architectural details.

Customization & Control

• Inspector & Script-Based Editing – Adjust dimensions, textures, and layouts in real-time.
• Randomization Tools – Generate varied buildings with randomized assets and dimensions.
• Texture & Material Support – Apply custom textures and materials to walls, roofs, and stairs.

Advanced Systems

• Object Pooling – Efficiently manage and reuse building elements.
• Procedural Roofs & Stairs – Generate roofs with different shapes and stairs with adjustable steps.
• Wall & Element Offsets – Fine-tune element positioning with X/Y offsets.

Optimized for Unity

• ScriptableObject-Based Workflow – Save and reuse building setups.
• Async Generation – Generate buildings without blocking the main thread.
• Editor Tools – Custom inspectors for easy setup and tweaking.

Use Cases

• Prototyping & Level Design – Quickly iterate on building layouts.
• Procedural Worlds – Generate varied structures for open-world or roguelike games.
• Architectural Visualization – Create stylized or realistic buildings.

ProceduralBuilding is a powerful Unity tool for dynamically generating customizable 3D buildings with modular walls, roofs, stairs, and textures. It features an advanced system for placing building elements (like windows, doors, or decorations) with support for empty wall spaces, allowing precise control over layout and design.

Key Features:

• Fully customizable – Adjust dimensions, textures, and layouts via inspector or script.
• Modular elements – Place and randomize building parts (walls, roofs, stairs) with ease.
• Procedural generation – Ideal for prototyping, level design, and open-world games.
• Supports empty wall spaces – Define gaps for doors, windows, or unique architectural details.

Best For:

• Prototyping & level design – Quickly iterate on building layouts.
• Procedural worlds – Generate varied structures for open-world or roguelike games.
• Architectural visualization – Create stylized or realistic buildings.
• Indie & AAA projects – Scalable for both small and large-scale environments.

Genre Suitability:

• Open-world, RPG, survival, city builders, simulation, and strategy games.
• Works with any art style (realistic, stylized, low-poly, etc.).