Asset Store newest packages

Read each package descriptions separately

This bundle includes 3 of complete f.1 racing games for all platforms. Ready to publish

Bundles includes:

___________________

=> F.1 Racing Game - $39

=> F.1 Racing Game 2 - $59

=> F.1 Racing Game 3 - $39

Purchase Guide:

After purchasing this bundle, you can download above packages for free with your same acount

Number of textures: 52

Texture dimensions: 4096x4096

Polygon count: about 2 000 faces each head

Number of meshes/prefabs: 13/13

Rigging: No

UV mapping: Yes

Types of materials and texture maps: PBR

Mixall studio presents a good solution for your games, VR projects and simulators:

Forest animals – Hunting trophies. A package of hunting trophies in the form of the heads of the most popular forest animals: bear, wild boar, fox, wolf and others.

★ Key Features ★

• 10 Hunting trophies heads
• PBR Textures
• low poly mesh grid

★ Assets ★

• 10 Hunting trophies: Bear, Boar, Deer, Moose, Lynx, Badger, Wolf, Fox, Roe Deer, Beaver
• 3 Wooden hunting medallions

★ Other Assets ★

Combine this asset pack with our other assets:

-Animals and insects - Big Pack

-Professions - Low-poly characters

-Beetles - pack of insects

-River fish - underwater world

-Cartoon birds - big animation pack

-Ocean fish - underwater world

-Reptiles and Amphibians - Animals Pack

-Characters pack - doctors and patients

-Sea Creatures - Shark, dolphin, stingray and turtle

-Spiders - characters with animations

-Sea fish - underwater world

-African animals - pack

-Soaring birds - animals for environment

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

★ Follow us on social media ★

INSTAGRAM | YOUTUBE | FACEBOOK

ARTSTATION | PINTEREST | DISCORD

• 8k atlas textures
• batching out of the box (all render pipelines)
• max vertices count per game object is around 2,000. Average is roughly 150 vertices and sharing the material with objects close by.

Includes enough assets to create all the cities for many types of games. A combination of environments, props, enterable buildings, and more! Make three distinct locations / points of interest for your game.

Environment Assets included in this bundle:

OWA Tech District

A tidy and fast sci-fi city building kit that is well optimized. Modular Kits, optimized buildings and urban cyberpunk props for building a unique futuristic grunge environment.

OWA Flower District

Complete urban district, complete with enterable buildings and doors. Lots of exterior urban props to build a modest sized town or city in a wide variety of genres from RPG, Fantasy, FPS/3rd person.

OWA Industrial District

A grungey environment to give your scenes a good foundation for survival games and shooters whther it be third person urban fights or first person competitive shooters. Create a district or entire city.

IMPORTANT: This is a bundle asset that grants access to the assets in the links above. After purchasing this asset, you must add the above assets to your shopping cart here on the Asset Store. When you checkout, you will be charged $0 for the assets, per this bundle license.

Minimum Unity version

• Unity 6 LTS (recommended and required minimum)

Key systems

• Shared UI, view and navigation foundation
• Unified system for menus, views, modals and navigation states, including view lifecycle and routing.
• Non-intrusive integration with gameplay systems
• Designed to connect existing gameplay logic to UI and flow without forcing architectural changes.
• Core runtime orchestration
• Initialization pipeline, task scheduling, timers, global services and event dispatching for predictable startup and execution flow.
• Centralized settings and configuration UI
• Ready-to-use configuration patterns for audio, graphics, language and system settings.
• ScriptableObject-driven configuration
• Menus, input, audio, localization and system behavior configured via ScriptableObjects.
• Safe persistence and file management
• File persistence with atomic writes, platform-specific file system services and data safety guarantees.
• View flow and screen management
• Structured handling of screen transitions, modal dialogs, view browsing and UI state.
• Audio systems orchestration
• Music and SFX playback, audio mixers, cross-fading and runtime audio control.
• Input abstraction and device handling
• Unity Input System integration with player join/leave, device policies and prompts.
• System configuration and platform providers
• Graphics settings, system monitoring and platform-specific providers (Windows / Linux).
• Asset prefetching and caching
• Addressables-based preloading for smooth scene and menu transitions.
• Logging and diagnostics
• Console and file logging with structured entries and configurable verbosity.
• Documentation tooling
• In-code XML documentation with DocFX generation and menu-integrated documentation entries.
  

Included Modules

Serenity includes modular, reusable systems that cover the most common foundations needed in Unity projects:

UI & Menus

• Menu and screen generation
• Navigation and screen flow
• Modal dialogs
• View browsing utilities
• Theme configuration and UI styling

Audio

• SFX and music playback
• AudioMixer routing and setup
• Music controller and cross-fading

Input

• Unity Input System integration
• Player input and device handling
• Device policies and primary input detection
• Input prompts and onboarding flows

Core Services

• Initialization pipeline and installers
• Event dispatching
• Timers and scheduling
• Logging and diagnostics
• System configuration services

Tooling & Infrastructure

• Asset prefetching and caching (Addressables)
• File persistence utilities
• Localization hooks
• Graphics settings helpers
• System providers (platform-level abstractions)

Customization workflow

A typical customization workflow looks like this:

1. Clone the template and set up your project.
2. Define menus, themes, input rules, audio, and system settings using ScriptableObjects.
3. Assign or extend installers to register services per platform or build target.
4. Style menus via theme assets and extend UI components using custom factories.

This approach allows teams to adapt the framework to different genres and production pipelines without modifying core systems.

Supported platforms

• PC
• Windows
• GNU/Linux
• macOS
• Mobile
• Android
• iOs
• Consoles (via Unity standard build pipelines)
• Supported via Unity standard build pipelines (PlayStation, Xbox, Switch).

Supported operating systems (development)

• Windows 10/11
• GNU/Linux
• macOS

Documentation

• In-code XML docs + DocFX site (add your public docs URL when ready)
• Example scenes demonstrating menu generation, theming, and prefetching

Serenity – Game Systems Foundation is a calm, production-ready foundation for Unity projects that provides a shared layer for UI, flow and settings — without forcing you into a rigid framework or base project.

Serenity is designed to fit into existing games, not replace their architecture. It acts as an infrastructural layer that connects gameplay systems to menus, navigation, settings and UI flow in a clean and predictable way, reducing coupling and repetitive boilerplate.

Instead of rebuilding menus, settings screens, audio options and UI flow in every project, Serenity gives you a stable foundation you can rely on from early prototypes to long-term productions.

What Serenity provides

• Shared UI, flow and settings foundation
• A single, consistent layer for menus, navigation, screen flow and configuration.
  
• Non-intrusive integration with gameplay systems
• Connect existing gameplay systems to UI without restructuring your architecture.
  
• Structured Menu and screen flow management
• Explicit handling of menus, screens, modals and navigation states.
  
• Centralized settings and configuration UI
• Ready-to-use patterns for audio, graphics, language and other runtime settings.
  
• Modular and extensible structure
• Use only the parts you need and extend them to fit your project.
  
• Built for scalability and long-term maintenance
• Suitable for prototypes, live projects and long-running productions.
  
• Clean Architecture and Domain-Driven Design inspired
• Clear boundaries, explicit responsibilities and installer-based setup.
  

Designed for maintainability

Serenity is intentionally focused on being a quiet, reliable foundation that supports your project without getting in the way.

It does not try to be a “do-everything framework”.

It can function as:

• A lightweight UI foundation
• An infrastructural layer alongside existing Unity UI systems
• A long-term structural base for scalable projects

Who it is for

Serenity is designed for developers who value long-term maintainability and clean structure over short-term hacks.

It is a good fit for:

• Developers building multiple projects who need consistency
• Teams with existing gameplay systems
• Projects that require structured UI and flow without architectural lock-in

🧩 Technical Details

• Total prefabs: 93
• Total tris for each prefabs: Between 12 verts to 43K verts
• 32 unique material sets for optimal quality and performance
• Colliders: Custom mesh colliders and primitive colliders included
• Textures: PBR, optimized for modular use (4096 to 1024). Downgrade as you need for better performance on mobile.

⭐ Community ⭐

Join the Friday Night Studio Discord for support, exclusive updates, freebies, vouchers, and early access to new packages 🎁:

🚀 FRIDAY NIGHT STUDIO - DISCORD 🚀

🤝 Overview

This modular Futuristic Environment Pack was made in collaboration with Guillaume Fortin, Environment Artist, and is ready to use in any production. You can choose either the black or white workflow, as both are included in this package.

Take a look at my unity asset store page for more futuristic environments! ✨🏞️

• Friday Night Studio - Unity Asset Store

Perfect for PC, consoles, VR, Mobile, games, cinematic projects, and interactive experiences. 🎮🎥

• Fully modular parts with PBR Metallic Roughness workflow.
• Game-ready prefabs and materials.
• Optimized colliders for smooth gameplay.
• Demo scenes included for easy showcase and testing.

🚀 Pipeline Compatibility

🛠️ All materials and prefabs already converted and ready to use.

• Built-in Render Pipeline ✅
• Universal Render Pipeline (URP) ✅
• High Definition Render Pipeline (HDRP) ✅

Lighting and post-processing settings vary between pipelines — adjust as needed for your scene. 💡

⭐Follow us for updates, promotions, previews & more⭐:

DISCORD | INSTAGRAM

• HDRP, Standard & URP support.

• 1 Shader for all VFX Assets

💥 Toon Hits & Projectiles 💥

Add impact and personality to your game with Toon Hits & Projectiles, a VFX pack packed with stylized hits and dynamic projectiles in a bold cartoon style.

From snappy hit sparks to exaggerated impact bursts and a wide range of projectile types, the effects are designed to feel responsive, readable, and satisfying in motion. Whether you're building fast-paced combat, arcade shooters, or ability-driven systems, this pack helps every action land with clarity and style.

Crafted with strong silhouettes and timing in mind, the effects cut through visual noise while keeping a playful, high-energy aesthetic. Easy to integrate and highly versatile, you can mix and match elements to create everything from subtle hits to over-the-top cartoon chaos.

Optimized for mobile, console, and PC, with support for Built-in, URP, and HDRP.

💥 Key Features 💥

• Minimal set-up to get it working on your own mesh
• 1 Shader for all particles
• Includes overview scene and usage examples
• Compatible with Built-in, URP, and HDRP
• Drag and Drop

• Scans entire Assets folder in seconds

• Shows Top 20 largest files sorted by size

• Detects potentially unused assets using dependency analysis

• Displays total reclaimable disk space

• One-click selection and per-asset deletion

• Bulk delete option with confirmation dialog

• Safe workflow with manual review before deletion

• Clean, dockable Unity Editor window

• Works with Built-in, URP, and HDRP

• Editor-only tool (no runtime impact)

• No dependencies required

• Compatible with Unity 2021.3 LTS and newer

Project Slimmer helps you instantly find and remove unused assets in your Unity project.

Over time, projects accumulate unused files like textures, audio clips, prefabs, and scripts. These increase build size, slow down imports, and clutter your workflow. Project Slimmer gives you a clear overview of what is taking up space and what can potentially be removed.

The tool scans your entire project and highlights:

- The largest files consuming disk space

- Assets that are not referenced anywhere in your scenes or prefabs

You can safely review, select, and delete unused assets directly from a clean and intuitive editor window.

Project Slimmer is designed to be fast, simple, and safe, making it ideal for both small indie projects and large productions.

No setup required — just open the window and start cleaning.

🔗 Watch real character demo on UTube:

"Cinematic Third‑Person Controller – 13 Animator States" (Unity.6) demo character-YazanDev- - YouTube

Cinematic Third-Person Controller – 13 Animator States

A complete, third‑person controller for Unity. Includes a full movement system (walk, run, strafe left/right, backward, crouch with four states) and a professional camera system with orbital half‑circle (mouse up/down = head/feet), mouse wheel zoom, investigation/aim mode, head bobbing, landing shake, dynamic FOV on sprint, and optional collision that does not break zoom. Designed for immersive gameplay – ideal for horror, adventure, open‑world, or story‑driven games.

Camera System Features:

• Orbital half‑circle – mouse up looks at head, mouse down looks at feet
• Mouse wheel smooth zoom with easing (adjustable min/max distance and speed)
• Investigation / aim mode – right click snaps to closer offset (custom position, rotation, FOV)
• Head bobbing – subtle camera movement while walking/running (separate walk/run strength and speed)
• Landing shake – camera vibrates when falling from height (adjustable duration and magnitude)
• Dynamic FOV – field of view widens smoothly while sprinting(Left Shift)
• Crouch camera customization – camera height lowers smoothly when crouching (adjustable offset and transition speed)
• Full Inspector controls – toggle every feature on/off, adjust speeds, distances, pitch limits, easing

Movement System (Controller) Features:

• Complete movement: walk, run, strafe left/right, backward, crouch (idle, walk, strafe left/right, backward)
• 13 animator states ready: Idle, Walk, Run, Strafe Left, Strafe Right, Backward, Crouch Idle, Crouch Walk, Crouch Strafe Left, Crouch Strafe Right, Crouch Backward, Blend Run→Walk, Blend Run→Idle
• Smooth transitions between states – all parameters pre‑wired
• Mouse look – horizontal rotates player, vertical controls camera pitch (adjustable sensitivity, aim sensitivity)
• Crouch – Left Control (modifiable)
• Aiming – right mouse button toggles aiming mode (camera switch, FOV change)
• Clean, commented C# scripts – easy to extend
• Includes: Demo scene, Animator Controller (13 states), PDF documentation

Perfect for:

• Survival horror
• Mystery investigation
• Open‑world exploration
• Cinematic adventure games
• Stunning environments

Input System: Both

Animations and character models not included.

Made by YazanDev

- SaveManager singleton with full save/load API

- Multi-slot system (manual and autosave)

- Autosave with configurable interval and slot rotation

- Backup system with multiple fallback layers (bak1, bak2, bak3)

- JSON-based save format with versioning support

- Runtime-spawned object persistence (PrefabId system)

- Scene-based save separation and merging

- ISaveable interface for custom data

- Built-in serializers (Transform, primitives)

- Data integrity and safe write pipeline (temp + backup)

- Slot metadata (timestamp, scene, playtime)

- Validation tools for setup issues

- Demo scenes included (basic, runtime spawn, advanced safety)

SaveSystemPro is a production-ready save and load system designed to prevent data loss and simplify persistence in Unity projects.

It provides a complete solution for managing player progress, including multi-slot saves, autosave, backup recovery, and runtime object persistence.

The system is designed to be easy to integrate while remaining highly flexible for advanced use cases.

Key capabilities:

- Reliable save/load architecture

- Multi-slot system with manual and automatic saves

- Backup and recovery system to protect against corrupted saves

- Runtime spawn support for dynamically created objects

- Scene-based save separation

- JSON-based save files for easy debugging and extensibility

The included demo scenes demonstrate common workflows such as saving player position, handling runtime objects, and recovering from simulated data loss.

This system is suitable for all types of Unity projects, from small prototypes to production-scale games.

Requirements

• Unity version: 2020.3 LTS or later (uses PrefabUtility.SaveAsPrefabAsset, AssetPreview.GetAssetPreview, and MonoScript.FromScriptableObject, all available since 2018.4+; tested and recommended on 2020.3+)
• Render pipeline: Any (URP, HDRP, Built-in) — this is an Editor-only tool with no runtime dependencies
• Dependencies: None. Uses only built-in Unity Editor APIs (UnityEngine, UnityEditor, System.IO)
• Platform: Works on all platforms supported by the Unity Editor (Windows, macOS, Linux)

Installation

Typical Package Manager Installation

1. After purchasing Object Reference Manager on the Unity Asset Store, click the Open in Unity button on the store page. This automatically opens the Package Manager window in your Unity Editor and navigates to My Assets with the package selected.
2. In the package details panel, click Download to download the package to your machine. A progress bar will appear while the download completes.
3. Once the download finishes, the button changes to Import. Click it to begin importing.
4. The Import Unity Package dialog appears with all package contents pre-selected. Optionally uncheck any items you do not want to include, then click Import.
5. The Package Manager places the imported files into your project’s Assets folder, where they are accessible from the Project window.

After Import

Allow Unity to compile the newly imported scripts. Once compilation finishes, the tool is ready to use — no additional setup is required. The following assets will be present in your project:

Assets/BBB/ObjectReferenceManager/
├── Editor/
│ └── ObjectReferenceManager.cs
├── ObjectReferences.cs
├── ObjectReferenceManagerData.asset (created automatically if missing)
└── Prefabs/ (created automatically on first use)

Note: This tool will eventually be offered as part of a package of Editor Utilities, but I don't know how soon. If you do buy this now any amount paid will be deducted from the package amount later only to a maximum discount (if you had bought multiple individule tools) that the package is free. But, if you buy the package later you get all the tools therein plus any new ones added over time.

Tool Document

Note on Expectations

Object Reference Manager is a Unity Editor extension that gives you a dedicated window for storing, organizing, and reusing GameObject references across your project. Instead of hunting through deep folder hierarchies or losing track of frequently used assets, you can keep them all in one dockable panel — complete with 64×64 thumbnail previews — and drag them directly into your scenes.

What sets Object Reference Manager apart is its automatic prefab variant workflow. When you drag a scene object into the manager, it detects that the object is not yet a persistent asset and automatically creates a prefab variant in a dedicated Prefabs subfolder. This means you never accidentally store a reference to a transient scene object that would break the next time you reload. Every reference in the manager is guaranteed to point to a real, saved asset.

The tool stores all its data in a single ScriptableObject asset, so your reference list persists across Editor sessions, domain reloads, and even source control operations. It uses self-resolving asset paths — the window locates its own data files at runtime based on where the script is installed, so it works regardless of where you place it in your project and is fully compatible with symlinks and custom folder structures.

Key Features

Persistent GameObject reference array stored in a ScriptableObject asset that survives Editor restarts and domain reloads

• Automatic prefab variant creation — scene objects dragged into slots are automatically converted to prefab assets saved in a Prefabs subfolder
• Drag-out support — drag objects from the manager window directly into the Scene view or Hierarchy via their thumbnail previews
• 64×64 asset preview thumbnails for every slot, providing quick visual identification
• Row selection via checkboxes with bulk Clear Selected and Clear All operations
• Resizable array with a confirmation dialog to prevent accidental data loss
• Right-click context menu on thumbnails to clear individual object references
• Self-resolving asset paths — uses MonoScript.FromScriptableObject to locate its own install directory at runtime; no hardcoded paths, fully symlink-safe
• Zero configuration — data asset and Prefabs folder are created automatically on first use
• Scrollable interface that handles arrays of any size

• Unity Version: 2021.3 LTS or later
• Render Pipelines: Any (editor-only tool, no runtime dependency)
• Editor Platforms: Windows, macOS, Linux
• Runtime Scripts: None — editor-only
• Assembly: ZantAssets.StylizedFolder
• Storage: Settings saved as StylizedFolderSettings.json
• Package Type: Editor Extension
• Dependencies: None
• Source Code: Closed

Keep your Unity projects clean and instantly recognizable. Stylized Folder lets you assign custom colors, row highlights, and emojis (or built-in Unity icons) to any folder in the Project window and any GameObject in the Hierarchy — so you can navigate large projects at a glance.

Features:

• Folder icon tinting — Apply any color to folder icons in the Project window
• Row highlight — Color the entire label row behind a folder or asset for bold, at-a-glance navigation
• Emoji & icon overlays — Attach any emoji or Unity built-in icon as an overlay badge on folders and GameObjects
• Hierarchy support — Style GameObjects directly in the Hierarchy window, not just Project folders
• Apply to children — Propagate a parent's style automatically to all child GameObjects
• Style clipboard — Copy and paste styles between folders and objects in one click
• Full Emoji Picker — Organized, searchable emoji picker with 11 categories (Smileys, Animals, Food, Travel, and more)
• Quick Color Picker — Compact utility popup for fast color and highlight assignments
• Per-item visibility toggles — Show or hide color, highlight, or emoji independently per item
• Global toggles — Instantly show or hide all colors, highlights, or emojis project-wide
• All Project window view modes — Works in list, small icon, and large grid layouts
• Persistent settings — All styles are saved as a JSON file and survive editor restarts

1. Digital Delivery Only

2. 14 tracks

3. 44.1 kHz, 16bit audio files

4. WAV format

5. Loopable

The Sky That Remembered Us (Cinematic Fantasy Music for TTRPG & Games) is a cinematic fantasy music pack inspired by classic JRPG soundtracks, designed to elevate immersive gameplay and storytelling.

Featuring 14 high-quality, loopable tracks, this collection blends orchestral arrangements with emotional melodies and atmospheric layers. From peaceful exploration and heartfelt moments to epic journeys and tense encounters, each track is crafted to support a wide range of in-game scenarios.

Perfect for RPGs, open-world adventures, visual novels, and TTRPG sessions, this pack helps bring your world to life with a nostalgic yet modern fantasy sound. All tracks are delivered in 44.1 kHz, 16-bit WAV format, ready for seamless integration into your project.

• The Atlas uses C# Reflection and Regex parsing for deep code analysis.
• Optimized via UI Toolkit and GraphView for handling projects with hundreds of scripts.
• Includes .asmdef for faster compilation and a clean, modular project structure.

Key Features:

• Instant Dependency Mapping: Automatically scans your scripts and draws connections based on inheritance, method calls, fields, and events.
• Smart Boxing: Group related nodes into "Boxes" to keep your workspace clean.
• Focus Mode: Highlight only the selected node and its direct neighbors to eliminate visual noise.
• IDE Integration: Double click any node or connection line to jump straight to the exact line of code in your IDE (Visual Studio, JetBrains Rider, etc.).
• Search & Navigation: Quickly find any class or interface in a massive graph with the built-in search field.
• Layout Presets: Save your node positions as assets - your map won't get messed up after restarting Unity or reloading the scene.

Tracked Relations:

• Inheritance: Base classes and inheritance chains.
• Interfaces: Interface implementations and method mapping.
• Method Calls: Direct function calls between classes.
• Fields: References via variables (including Lists and Arrays).
• Properties: Separate tracking for Get and Set access.
• Events: C# Event subscriptions and usage.
• Singletons: Access via .Instance, .Shared, and .Main patterns.
• Static Access: References to static members and constants.
• Unity API: GetComponent<T> calls and dependencies within Debug.Log contexts.
• Type Support: Visualization for Class, Struct, Interface, Abstract, and Enum.

Note: The Atlas is a visualization and architecture analysis tool. It is designed to map and analyze your existing C# code and is not a visual scripting solution or a tool for creating game logic without writing code.

• Editor-only Unity tool

• Compatible with Unity 2021.3 and newer

• Works independently of Built-in, URP, and HDRP render pipelines

• No runtime dependencies

• Dedicated editor window for object and component selection

• Copy Snapshot output

• Copy Prompt + Snapshot output

• Support for multi-object selection

• Optional child hierarchy inclusion

• Per-object component selection controls

• Search/filter support for objects and components

• Compact Mode for reduced output noise

• Structured snapshot formatting for AI tools, debugging, and inspection

• Does not modify scene data or component values

AI Debug Snapshot for Unity is a lightweight editor tool that helps you inspect GameObjects, components, and hierarchies, then copy clean, structured snapshots for debugging, troubleshooting, refactoring, and AI-assisted analysis.

Instead of manually checking values one component at a time, you can select one or more GameObjects, choose exactly which objects and components to include, and instantly generate a readable snapshot of your setup. This makes it much easier to share scene data with ChatGPT or other AI tools, review suspicious values, explain unfamiliar objects, or quickly analyze hierarchy-level issues.

The tool is designed for developers who want a faster debugging workflow inside the Unity Editor. Whether you are inspecting a single object, reviewing a nested hierarchy, or preparing a compact snapshot for AI debugging, AI Debug Snapshot for Unity helps reduce friction and save time.

Key benefits:

• Copy structured GameObject and component snapshots in seconds

• Include or exclude specific objects and components

• Optionally include child objects in the snapshot

• Generate AI-ready prompt + snapshot output for faster analysis

• Use Compact Mode for cleaner, less noisy output

• Search objects and components quickly inside the editor window

• Great for debugging, explanation, refactoring, and performance review workflows

This is an Editor-only utility and does not modify your scene, objects, or component values. It simply reads selected data and formats it into a clean, shareable snapshot.

Ideal for:

• Unity debugging workflows

• GameObject and hierarchy inspection

• AI-assisted troubleshooting

• Reviewing component setups

• Faster developer productivity inside the Unity Editor

Models

• Number of braziers: 5
• Meshes per brazier: 1
• LODs per brazier: 6
• Approx. triangle count (LOD0): ~25,000
• Lowest LOD triangle count: ~2,500
• Scale: 1 unit = 1 meter
• Orientation: Z forward, Y up
• Pivot: At base

Textures & Materials

• Texture resolution: 4K (4096×4096)
• Mask Map (R = Metallic, G = Occlusion, B = Edge (unused), A = Smoothness)Texture types included: Albedo / Base Color Normal
• PBR workflow
• Separate materials provided per render pipeline

Colliders

• Colliders: No colliders are added to the chests to allow flexibility of chest contents.

Compatibility

• Supported platforms: All platforms supported by Unity
• HDRPRender pipelines: Built-in URP

Additional Notes

• No runtime scripts included
• No third-party dependencies
• No project settings are modified on import

5 Dark Fantasy Braziers / Bowls is a curated pack of stylized Braziers designed for dark fantasy worlds.

Each Brazier is optimized for real-time use and includes multiple LOD levels for performance scalability.

Collider

Each prefab has a autogenerated convex mesh collider assigned.

Features

• 5 Dark Fantasy Braziers / Bowls
• Dark fantasy / stylized art direction
• PBR materials
• Multiple LODs per urn
• Consistent scale and orientation for game-ready use
• Demo scene for preview and inspection

Render Pipeline Support

This asset includes separate materials for:

• Built-in Render Pipeline
• Universal Render Pipeline (URP)
• High Definition Render Pipeline (HDRP)

No project settings are modified on import.

An optional editor-only helper is included to assist with material assignment in URP and HDRP.

Screenshots

All screenshots were taken on the Built-in Render Pipeline and contain no post processing.

Demo Scene

A lightweight demo scene is included for preview purposes.

It contains a simple camera orbit controller for inspection only and does not modify project settings or input mappings.

Models

• Number of chests: 4
• Meshes per chest: 2
• LODs per statue: 5
• Approx. triangle count (LOD0): ~35,000
• Lowest LOD triangle count: ~7,000
• Scale: 1 unit = 1 meter
• Orientation: Z forward, Y up
• Pivot: At base

Textures & Materials

• Texture resolution: 4K (4096×4096)
• Mask Map (R = Metallic, G = Occlusion, B = Edge (unused), A = Smoothness)Texture types included: Albedo / Base Color Normal
• PBR workflow
• Separate materials provided per render pipeline

Colliders

• Colliders: No colliders are added to the chests to allow flexibility of chest contents.

Compatibility

• Supported platforms: All platforms supported by Unity
• HDRPRender pipelines: Built-in URP

Additional Notes

• No runtime scripts included
• No third-party dependencies
• No project settings are modified on import

4 Dark Fantasy Treasure Chests is a curated pack of stylized Treasure Chests designed for dark fantasy worlds.

Each Treasure Chest is optimized for real-time use and includes multiple LOD levels for performance scalability. 

Mesh

Each chest is split into a top and bottom part. The top part has its origin point at the intended hinge of the chest. By rotating the hinge you can open and close the chest.

Features

• 4 Dark Fantasy Chests
• Dark fantasy / stylized art direction
• PBR materials
• Multiple LODs per urn
• Consistent scale and orientation for game-ready use
• Demo scene for preview and inspection

Render Pipeline Support

This asset includes separate materials for:

• Built-in Render Pipeline
• Universal Render Pipeline (URP)
• High Definition Render Pipeline (HDRP)

No project settings are modified on import.

An optional editor-only helper is included to assist with material assignment in URP and HDRP.

Screenshots

All screenshots were taken on the Built-in Render Pipeline and contain no post processing.

Demo Scene

A lightweight demo scene is included for preview purposes.

It contains a simple camera orbit controller for inspection only and does not modify project settings or input mappings.

Core Functionality:

• Asset Type: Editor Extension / Utility / API
• Primary Use: Offline Text-to-Speech (TTS) Generation, Audio Asset Creation, Dialog Prototyping
• Supported Engines: Piper (Local/Offline), Sherpa-ONNX (Local/Offline - including Kokoro models), ElevenLabs (Cloud API).

Compatibility:

• Unity Version: Requires Unity 2021.3 LTS or newer.
• Supported OS (Editor-Time): Windows 10/11 (x64), macOS (Intel & Apple Silicon), Linux (x64).
• Build Targets: The local AI generation is designed primarily for Editor-time use to generate static .wav files for your game builds. The runtime API (FrostSpeechAPI) can be used for runtime audio generation but requires manual binary packaging for your target platform. ElevenLabs API generation works at runtime on any platform with internet access.

Architecture & Dependencies:

• Dynamic Binary Downloading: To comply with Unity Asset Store guidelines (and avoid GPLv3 viral licensing issues with eSpeak-NG), core engine binaries (.exe, macOS, Linux executables) and AI .onnx models are NOT included in the initial .unitypackage. They are downloaded securely and automatically on-demand via the tool's built-in setup wizard into a hidden Binaries~ folder.
• UI Framework: Built entirely using Unity's modern UIElements (UI Toolkit) for a clean, responsive, and native Editor window experience.
• Scripting: Includes full C# source code (Namespaces: FrostemberStudios.FrostSpeechTTS). Utilizes async/await Tasks for non-blocking UI during downloads and generation. Uses UnityWebRequest for model downloading and ElevenLabs integration.

Data & Storage:

• Output Formats: Automatically generates and imports .wav files (for local Piper/Sherpa) and .mp3 files (for ElevenLabs cloud API) directly into the Unity Asset Database as AudioClip objects.
• Settings Storage: Uses custom FrostSpeechTTSProfile ScriptableObjects for character voice configurations and EditorPrefs for secure API key storage.
• Model Size: Be aware that downloading high-quality AI models requires disk space. Typical .onnx models range from 20MB to 100MB per voice.

Important Legal Note:

• The dynamically downloaded HuggingFace AI models come with varying licenses. Some are Public Domain/MIT, while others are restricted to Non-Commercial Use (CC-BY-NC). Please verify the specific license of the voice model before using generated audio in a commercial project.

Welcome to FrostSpeech TTS, the ultimate Text-to-Speech generation ecosystem for Unity. Whether you are building RPGs with thousands of dialogue lines, prototyping voiceovers, or creating final character voices, FrostSpeech delivers high-quality AI speech directly inside the Editor with zero hassle.

Stop wasting hours downloading Python scripts or paying hundreds of dollars for monthly cloud API subscriptions. FrostSpeech bridges the gap between premium AI voice generation and perfect Editor integration.

DOCUMENTATION | YOUTUBE SHOWCASE

🔥 Key Features

• Zero API Costs (100% Offline): Generating high-quality AI voices in the cloud is expensive. FrostSpeech integrates state-of-the-art local neural engines (Piper and Sherpa-ONNX) directly into Unity. Generate unlimited speech completely offline and for free!
• Next-Gen AI Models (Kokoro & More): Access hundreds of highly realistic, open-source voice models, including the widely acclaimed Kokoro TTS. The tool automatically downloads and manages these .onnx models behind the scenes.
• Premium Cloud Integration: Need the absolute best industry-standard voices? Switch the engine to ElevenLabs and generate premium cloud audio directly in your project using your own API key.
• Auto-Import & Caching Workflow: Say goodbye to manually moving files. Enter your text, adjust the sliders (Speed, Noise Scale), and click Generate. The tool automatically creates the .wav or .mp3 file, imports it into your Asset Database, and readies it as an AudioClip.
• Character Profile System: Maintain perfect consistency across your game's cast. Save and load specific generation settings (engine, voice model, speed, and pitch) per-character using our custom FrostSpeechTTSProfile ScriptableObjects.
• One-Click Setup Wizard: Get the entire local TTS ecosystem running in seconds. Upon first launch, the tool automatically downloads and extracts the necessary core binaries (.exe, macOS, or Linux) for your specific operating system.

💻 API & Scripting Triggering programmatic voice generation via code is incredibly easy using the included FrostSpeechAPI. Just pass your text and character profile to the asynchronous API, and receive a fully loaded AudioClip at runtime or in custom Editor tools. Perfect for dynamic quest dialogue systems.

Questions or need support?

contact@frostemberstudios.com

Number of Materials: 12

Number of Textures: 84

Texture Resolutions: 2048x2048

Texture maps: Base Color, Normal, Mask, Height, Metallic, Occlusion, Roughness

Supported Development Platforms:

Windows: Yes

Mac: Yes

This package contains 12 moss stylized PBR materials.

Texture maps:

• Base Color
• Normal
• Mask Map
• Height
• Metallic
• Occlusion
• Roughness

Features:

• 12 high quality PBR materials
• PNG format
• Seamless tileable material and textures

Number of Materials: 12

Number of Textures: 84

Texture Resolutions: 4096x4096

Texture maps: Base Color, Normal, Mask, Height, Metallic, Occlusion, Roughness

Supported Development Platforms:

Windows: Yes

Mac: Yes

This package contains 12 forest ground realistic PBR materials.

Texture maps:

• Base Color
• Normal
• Mask Map
• Height
• Metallic
• Occlusion
• Roughness

Features:

• 12 high quality PBR materials
• 4K Textures
• PNG format
• Seamless tileable material and textures

Number of Materials: 12

Number of Textures: 84

Texture Resolutions: 4096x4096

Texture maps: Base Color, Normal, Mask, Height, Metallic, Occlusion, Roughness

Supported Development Platforms:

Windows: Yes

Mac: Yes

This package contains 12 marble realistic PBR materials.

Texture maps:

• Base Color
• Normal
• Mask Map
• Height
• Metallic
• Occlusion
• Roughness

Features:

• 12 high quality PBR materials
• 4K Textures
• PNG format
• Seamless tileable material and textures