Asset Store newest packages

• 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.).

Core Architecture & Features:

• Audio Processing: Utilizes the Oculus LipSync engine for highly accurate real-time FFT phoneme detection (15 core visemes).
• Offline Baking System: Custom Editor Window (FaceSyncBaker) bakes complex audio analysis and procedural animation at 60 FPS into a lightweight ScriptableObject (FaceSyncAnimationAsset).
• Zero-CPU Playback: The FaceSyncPlayer component reads baked assets, eliminating runtime CPU cost for audio analysis, making it highly optimized for Mobile and VR.
• Native Timeline Integration: Custom Playable API implementation (FaceSyncTrack, FaceSyncClip, FaceSyncTrackMixer) supports smooth blending, editor scrubbing, and dynamic state overrides.
• Procedural Animation: Mathematical real-time generation of saccadic eye darts, micro-jitters, and voice-energy-driven Perlin noise for head and neck rotations.
• Auto-Mapping Profiles: VisemeMappingProfile includes algorithms to auto-generate mapping for ARKit (52 blendshapes) and Character Creator 3/4 standards.
• Live Input: Included Frostember_MicrophoneInput script captures system audio for real-time processing (VTubing/Multiplayer).
• Performance & LOD: Built-in distance-based Level of Detail (LOD) and frustum culling automatically disable processing when the mesh is off-screen or far away.
• GC Optimized: Runtime playback loops and Timeline mixers are built using array-based iterations to prevent Garbage Collection allocation spikes.

C# API: Clean and accessible API for triggering dialogue dynamically via code (.Play(), .Stop()).

Dependencies & Requirements:

• Requires the free Oculus LipSync Unity Integration package (Meta SDK). => Included in package
• Compatible with Built-in, URP, and HDRP render pipelines.

Works with any Humanoid or Generic rig that utilizes SkinnedMeshRenderer blendshapes.

Welcome to Frostember FaceSync, the ultimate audio-driven facial animation ecosystem for Unity. Whether you are building AAA cinematic cutscenes, highly optimized VR games, or live VTubing avatars, FaceSync delivers accurate lip-sync and procedural facial movements with zero hassle.

Stop wasting hours manually animating blendshapes or fighting with heavy real-time CPU loads. FaceSync bridges the gap between high-end realism and perfect optimization.

DOCUMENTATION + ROADMAP | FORUM | YOUTUBE

🔥 Key Features

• Zero-CPU Offline Baking: Real-time audio analysis kills frame rates on Mobile and VR. Our built-in Baker simulates the audio at 60 FPS in the Editor, baking visemes, procedural head noise, and blinks into a highly optimized FaceSyncAnimationAsset. Play it back at runtime with absolute zero CPU cost!
• Native Timeline Integration: Drag and drop your baked data into our custom FaceSync Track. Smoothly blend animations, scrub through time, and dynamically override eye and head behaviors directly from the Timeline Inspector.
• Procedural Eyes & Head Motion: Bring dead stares to life. FaceSync automatically calculates realistic blinking, saccadic eye darts, and micro-jitters. The head and neck procedurally react to the character's voice intensity using Perlin noise.
• 1-Click ARKit & CC3/CC4 Setup: Stop manually assigning dozens of blendshapes. Our VisemeMappingProfile features 1-click auto-generation for standard ARKit (52 blendshapes) and Character Creator rigs, creating highly accurate mouth shapes instantly.
• Live Microphone (VTuber Ready): Switch to Live Mode and use the included Frostember_MicrophoneInput component to drive your character's face in real-time using any connected microphone. Perfect for multiplayer voice chat and VTubers.
• Setup Wizard: Get your character fully rigged and talking in under 30 seconds using the automated Setup Wizard.

💻 API & Scripting

Triggering dialogue dynamically via code is incredibly easy using the FaceSyncPlayer component. Just assign the baked asset and call .Play(). Perfect for custom RPG dialogue and quest systems.

Questions?

contact@frostemberstudios.com

Number of textures: 37

Texture dimensions: 512‑1024‑2048

Number of meshes: 30

Number of prefabs: 34

UV mapping: Yes

Textures format: Png

Game‑ready Bathroom. Contains Interior of Bathroom with more

25 Optimized models.

Includes Bathroom, Toilet, Sink, Bath, Mirror, Closet, BathStands,

Lamps, Towel, Shampoo, Switch, Soap, Washing machine, Toilet paper, Window and Door.

Features:

Bathroom Scene and Demo Scene with Props

Optimized Meshes

Include Post Processing

Number of textures: 29

Texture dimensions: 512‑1024‑2048

Number of meshes: 20

Number of prefabs: 21

UV mapping: Yes

Textures format: Png

Bathroom Interior Game‑Ready Scene. Contains Interior of Bathroom with

20 Optimized models!

Includes Bathroom, Toilet, Sink, Bath, Mirror, Cupboard, BathStands,

Lamps, Towel, Shampoo, Switch, Soap, Washing machine, Toilet paper and Door.

Features:

Bathroom Scene and Demo Scene with Props

Optimized Meshes

Include Post Processing

Number of textures: 30

Texture dimensions: 512‑1024‑2048

Number of meshes: 25

Number of prefabs: 30

UV mapping: Yes

Textures format: Png

Bathroom. Contains Interior of Bathroom with more

20 Optimized models!

Includes Bathroom, Toilet, Sink, Bath, Mirror, Closet, BathStands,

Shower, Lamps, Towel, Shampoo, PowerSocket, Switch, Soap,

Washing machine, Toilet paper and Door.

Features:

Bathroom Scene and Demo Scene with Props

Optimized Meshes

Include Post Processing

texture size：512x512

Number of texture map：

Apollo（7）

Artemis（9）

Includes 2 characters

Apollo,Artemis

Material is using RealToon (Pro Anime/Toon Shader)

Polycount:

Apollo:4844 triangles

Artemis: 3818 triangles

Rigging:Yes

Animation Type: Generic

Apollo Animation:

appear,attack(2),behurt,dead,idle,revive,show,victory

Artemis Animation:

attack(3),behurt,dead,idle,victory

• Unity Version: 2021.3 or newer recommended
• Render Pipeline: Built-in, URP, and HDRP compatible
• Runtime Language: C#
• Architecture: Object-based save system
• Serialization: JSON-based serializer
• Assembly Structure: Runtime and Editor assemblies separated
• Runtime Prefab System: Supports dynamically spawned objects
• Scene Awareness: Objects restore in their original scene
• Save Slots: Multiple independent save files supported
• Editor Tools: Debugging and validation utilities included
• Platform Support: PC, Mac, Linux, Android, and iOS

Lite vs Full Version

ChronoSave Lite includes the core save functionality.

The full version of ChronoSave adds advanced features including:

• Encrypted save files
• Save file tamper detection
• LZ4 save compression
• Async save execution
• Dirty object tracking optimization
• Save migration system for long-term project compatibility
• Save profiler tools
• Screenshot metadata for save slots
• Advanced Unity object reference persistence

ChronoSave Lite is a lightweight Unity save system designed to provide a simple and reliable way to implement save and load functionality in your games. It allows developers to persist game data such as player progress, object states, and runtime-generated content without relying on PlayerPrefs or manual key-value storage.

Built with an object-based save architecture, ChronoSave Lite ensures that game objects maintain stable identities across scenes and play sessions. This makes it easy to save and restore player data, world state, and runtime-spawned objects such as enemies, pickups, and interactable items.

The system supports multiple save slots, scene-aware loading, and runtime prefab restoration, making it suitable for many types of projects including RPGs, simulations, survival games, and sandbox experiences.

ChronoSave Lite also includes developer-friendly editor tools that allow you to inspect save data, validate project setup, and manage save files directly from the Unity Editor.

This Lite version provides the core save system functionality needed for most projects, while the full version of ChronoSave adds advanced features such as encryption, compression, migration support, and performance optimization tools.

Key Features

✓ Object-based save system (no key-value hacks)
✓ Stable SaveIdentity system for persistent objects
✓ Multiple save slots
✓ Scene-aware save and load system
✓ Runtime-spawned prefab restoration
✓ Save Groups for selective saving
✓ Global (cross-scene) data support
✓ Editor tools for debugging and inspecting save data
✓ Setup validation tool
✓ Save slot overview tool
✓ Prefab registry system
✓ Platform-agnostic architecture

• 11 original music tracks (loops & stems included)
• Full track list with BPM and durations provided in description
• WAV format (44.1 kHz / 24-bit)
• Total package size: 3.6 GB
• All tracks include seamless loop versions
• Each track includes individual stems (Drums, Bass, Synths, FX, Atmospheres)
• BPM and key information included in file naming
• Audio is grid-aligned for adaptive music systems
• Organized into per-track folders
• Each folder contains:
• Full mix
• Loop versions
• Individual stems
• No external dependencies
• Compatible with all Unity render pipelines (audio-only asset)

Number of Music Tracks: 11 (Loops & Stems Included) 

File Format: WAV

Sample Rate / Bit Depth: 44.1 kHz / 24-bit

Total Size: 3.6 GB

Full Track List (Includes Loopable Versions & Stems)

1. It Begins — 160 BPM — 2:55
2. Chopper Rescue — 180 BPM — 4:20
3. Dune Snipers — 89 BPM — 4:02
4. Abazred Lives — 160 BPM — 3:16
5. Patria — 157 BPM — 2:16
6. The Age of Gods — 144 BPM — 3:08
7. Hatchet and Dagger — 170 BPM — 3:00
8. Narrow Alliance — 120 BPM — 7:31
9. Early Access — 155 BPM — 2:03
10. Hyper Beat — 180 BPM — 4:25
11. Doomed and Evolved — 120 BPM — 3:24

Loop & Stem Details

• All tracks include seamless loop versions
• Each track folder contains individual stems (Drums, Bass, Synths, FX, Atmospheres)
• BPM and key information included in file naming
• Audio is grid-aligned for adaptive music systems

File Structure

• Organized into per-track folders
• Each folder contains:
• Full mix
• Loop versions
• Individual stems

Support & Custom Requests:

For questions, feedback, or custom music inquiries, visit:

gustavodebeauville.com

• Unity Version: 2021.3 LTS and above
• Tested Up To: Unity 6
• Platform: Windows, macOS
• Editor Only: Yes — no runtime components
• Dependencies: None
• Backup Format: .unitypackage & native Unity project structure

How It Works ?

SafePoint PRO monitors your Unity Editor for critical events and automatically creates a named SafePoint before each one. Every SafePoint is labeled by context - "Before Build", "Before Compile", "Startup" (and more) - so you always know exactly what you're restoring to.

When something goes wrong, open the timeline -> select your point -> click Restore. Done.

SafePoint PRO: User Documentation

🛡️🛡️🛡️ Key Features 🛡️🛡️🛡️

Automatic SafePoints

Restore points are created automatically — no manual action needed. Configure how often and at which events SafePoints are created using one of four Automation Plans.

9 Smart Triggers

SafePoints are created automatically at:

✅ Project Startup

✅ Scheduled Interval

✅ Before Play Mode

✅ Before Script Recompile

✅ Before Build

✅ Before Package Import

✅ Before Platform Switch

✅ Before Restore

✅ and Manual.

4 Automation Plans

Choose your level of protection:

✅ OFF - Manual only

✅ SAFE - Balanced, fixed time intervals

✅ ADVANCED - All 9 triggers active, maximum safety

✅ CUSTOM - Pick your triggers, set your own interval and SafePoint limits

Unity Package Export

✅Export your project as a .unitypackage file in one click.

✅Auto-named and timestamped. Import into any Unity project instantly.

⭐ Favorites

Pin your most critical SafePoints as Favorites. Favorites are always accessible and are never auto-deleted — no matter how many new SafePoints are created.

💎Backup Scope Control

Choose exactly which folders are included in every SafePoint. A live size estimate updates in real time so you always know how much space you're using.

Who Is It For?

SafePoint PRO is built for any Unity developer who values their work. No matter your skill level, project size, or workflow - your work has value and it deserves to be protected -> SafePoint PRO has you covered.

Why SafePoint PRO?

✅ Zero setup -- works immediately after import

✅ Runs automatically in the background

✅ Every SafePoint is named so you always know what to restore

✅ Pin critical SafePoints as Favorites

✅ Lightweight backups -- typically under 1 MB per SafePoint

✅ Full folder-level control over what gets backed up

✅ Focus on building -- no worries.

SafePoint PRO: User Documentation

❓ Frequently Asked Questions ❓

What is a SafePoint?

A lightweight backup of your project created automatically at critical moments — before a build, compile, import, and more. Each one is named by context so you always know what to restore.

Does it work with Git, SVN, or Plastic?

Yes. SafePoint PRO works alongside any version control. It fills the gaps Git doesn't cover — mid-session crashes, bad compiles, and broken imports between commits.

Does it slow down the Unity Editor?

No. It runs silently in the background and only activates at trigger moments. Zero impact on Editor performance.

How much disk space does it use?

A typical SafePoint is under 1 MB. You control which folders are included and how many SafePoints to keep, so storage stays predictable.

Can I choose what gets backed up?

Yes. The Backup tab gives you full folder-level control. Large binary assets like textures and audio are excluded by default to keep backups small and fast.

What happens when I reach the SafePoint limit?

The oldest SafePoints are removed automatically. Favorites are always protected and never auto-deleted.

Can I restore without overwriting my current project?

Yes. Restore as Copy restores any SafePoint into a separate folder, leaving your current project completely untouched.

Do I need to configure anything before it starts working?

No. It works immediately after import with zero setup. Full protection starts the moment you open your project.

Is this a one-time purchase?

Yes. One-time purchase. No subscriptions, no recurring fees, no internet connection required.

Unity SafePoint PRO

Go Back In Time. Anytime.

Intelligent Labs ❤️