Asset Store newest packages

• Hand Tracking Type: Real-time monocular camera-based hand tracking
• Landmark Tracking: 20+ 3D landmarks per hand (wrist, palm, finger joints)
• Hand Detection: Automatic left and right hand identification
• Mesh Animation: Full 3D hand mesh animation with finger joints and wrist rotation
• Movement Tracking: World-space hand position, rotation, and scale tracking
• Gesture Support: Landmark-based data suitable for custom gesture and action detection
• Input Sources: Device camera, video file, static image
• Tracking Models:
  Lite Model (optimized for mobile performance)
  Heavy Model (higher accuracy)
• Rendering Support: Built-in Render Pipeline, URP, HDRP
• Platforms: Android, iOS, Windows, macOS
• Unity Version: 2021 or later
• Dependencies: None (works without AR SDK)
• Setup: Plug-and-play prefabs with demo scenes included

AR Hand Mesh Tracking is a powerful plugin that enables real-time hand tracking, full 3D hand mesh animation, and AR-style hand interaction — without using any AR SDK.

The plugin detects left and right hands, tracks 20+ 3D hand landmarks, animates realistic 3D hand meshes, and follows hand movement in world space, allowing developers to build gesture-based AR interactions using only a camera.

Unlike traditional AR solutions, this system does not rely on AR Foundation, ARCore, or ARKit. It is ideal for lightweight AR experiences, rapid prototyping, and projects that need hand-based interaction before integrating an AR SDK.

Key Highlights

• Real-time hand landmark tracking (20+ points per hand)
• Full 3D hand mesh animation
• Hand movement tracking (position, rotation, scale)
• AR-style hand mesh interaction (no AR SDK required)
• Left & right hand detection
• Gesture & action detection ready
• Interact with AR objects, UI, and physics items
• Supports Camera, Video, and Image input
• Lite & Heavy models for performance control
• Mobile and desktop friendly
• Plug-and-play prefabs with demo scenes

Perfect For

• AR hand interaction systems
• Gesture-based games and applications
• Mobile AR experiences
• AR prototyping and experimentation
• HCI, research, and education projects
• Hybrid AR projects using or preparing for AR SDKs

If you’re looking for a fast, flexible, and SDK-free solution for AR hand tracking, AR Hand Mesh Tracking gives you everything you need to build natural, hand-driven interaction.

Features

• Scene Scanning
• Project Scanning
• Smart Fixes
• Missing Scripts
• Build Safety
• Review Window
• Undo Support
• JSON Export
• Zero Overhead
• Auto Suggestions
• Prefab Safety
• ScriptableObject Scan

Supported Unity Versions

• 2019.4 LTS
• 2020.3 LTS
• 2021.3 LTS
• 2022.3 LTS
• 2023.x / Unity 6 / Above 
• Compatible with all future versions

Supported OS

• Windows
• macOS
• Linux

Documentation -> Online Documentation

⚠️ Stop shipping builds with broken references

Deleting scripts, renaming folders, prefab overrides, branch merges—Unity projects slowly collect missing references and “Missing Script” components. These issues silently grow until they explode as NullReferenceExceptions or failed builds.

Missing Reference Killer is a Unity Editor tool built to find, review, and safely fix these problems before they reach runtime.

This tool is not a passive logger. It actively scans your project and shows you exactly where things are broken—clearly, early, and safely.

🔍 Deep & Accurate Scanning

• Scene Scan
  Detects missing references and broken components in the active scene.
• Project-Wide Scan
  Scans Prefabs and ScriptableObjects across your Assets folder.
• Missing Script Detection
  Finds ghost components left behind after deleted or renamed scripts.

Issues are clearly color-coded so you can instantly see what is critical and what is safe to clean.

🧠 Smart Suggestions & Safe Fixing

• Smart Suggestions
  Analyzes variable names and expected component types to suggest correct fixes.
• Safe Fix Mode
  Apply supported fixes without touching critical data.
• Review Window
  Preview every change with Old Value → New Value before applying.
  Nothing is applied blindly.

🛡️ Build Safety Guard

• Pre-Build Scan
  Automatically checks for broken references when you press Build.
• Build Protection
  Stops the build and alerts you if critical issues are found—saving you from shipping a broken game.

🌟 Why this tool?

This isn't just a scanner; it's a workflow accelerator. We built it to be the "Check Engine Light" for your Unity project. It handles everything from simple null fields to deep complex prefab data corruption.

📊 Professional Workflow Tools

• Clean, structured results view
• Group and filter issues by Scene, Asset type, or severity
• Export scan results as JSON for audits or team use

⚡ Key Benefits

• Editor-only tool (zero runtime overhead)
• Full Undo / Redo support
• Works with large projects and refactors
• Compatible with Addressables and modern Unity workflows

Missing Reference Killer is designed for developers who care about stability, clean projects, and stress-free releases.

Clean project.
Safe builds.

Keep your project clean. Keep your sanity. Get Missing Reference Killer today.

- "by DecNet"

JOIN DISCORD | DOCUMENTATION | OTHER ASSETS

9 prefab

9 model

LowPolyNature-MiniPack

This free low poly pack has 9 prefabs. All models are ready to put in scene.

All models are optimized with approximately 90-100 tris each.

-3 Tress

-3 Bushes

-2 Grasses

-1 Rock

All models use the same texture and material.

Don't forget to ranked the package if you download it.

Thank you!

The package catches up the active ProjectBrowser Editor Windows and edits the Title GUIContents of each Locked Project Tabs according to a selected Titling Mode Settings.

This package modifies the Project tab titles to easily distinguish between multiple Project tabs. Works only with Two Column Layout.

The package includes multiple titling modes:

• Folder Only. Title consist of the lowest level folder name
• Wrap. A fancy path compress mode.
• Shrink. The maximum symbols within the given Limit used.
• RegEx. Setup your desired way of titling.

How to use:

The package activates immediately. The Titling mode Settings can be found on the top menu: Window/Titled Project Tabs Settings

- Unity 2021.3 LTS or newer

- Built-in, URP, and HDRP compatible

- Separate Runtime and Editor assemblies

- Zero runtime allocations

- No third-party dependencies

- IL2CPP and Mono compatible

- Namespace: DawgTools.Smooth

QUICK START

using DawgTools.Smooth;

using UnityEngine;

public class SmoothExample : MonoBehaviour

{

    public float halfLife = 0.12f;

    float _value;

    void Update()

    {

        float target = Mathf.Sin(Time.time) * 10f;

        _value = Smooth.ExpHalfLife(

            _value, target, halfLife, Time.deltaTime);

    }

}

LICENSE

Licensed under Unity Asset Store EULA.

DAWG Tools - Smooth PRO

Most Unity projects have code like this:

current = Mathf.Lerp(current, target, 0.1f);

It runs every frame, applying a fixed percentage step toward the target. At 30 FPS it applies 30 times per second. At 144 FPS it applies 144 times per second. Players on faster machines see faster smoothing.

The fix is one line:

current = Smooth.Exp(current, target, 10f, Time.deltaTime);

Same behavior at every frame rate. The math uses exp(-speed * dt) which naturally compensates for variable frame times.

Use cases: camera systems, UI motion and transitions, gameplay parameter smoothing, audio interpolation, network / multiplayer interpolation.

WHAT'S INCLUDED

Exponential Smoothing (Smooth class)

- Smooth.Exp — frame-rate independent exponential smoothing

- Smooth.ExpHalfLife — parameterized by half-life (designer-friendly: "halfway to target in 0.2 seconds")

- Smooth.ExpAngle — wrap-safe angle smoothing (no snapping at 0/360)

- Overloads for float, Vector2, Vector3, Quaternion, Color

Spring Dampers (Spring class)

- Spring.Critical — fastest convergence, no overshoot

- Spring.Damped — general-purpose, any damping ratio

- Spring.Bouncy — configurable overshoot and oscillation

- Overloads for float, Vector2, Vector3

- Adaptive substepping for frame-rate stable results

Easing Functions (Ease class)

- 30+ standard curves: Quad, Cubic, Quart, Quint, Sine, Expo, Circ, Back, Elastic, Bounce

- In / Out / InOut variants for each

- SmoothStep and SmootherStep (Hermite / Perlin)

- Ease.Lerp helper combining easing + interpolation

Conversion Utilities

- SpeedFromBrokenLerpT — convert existing lerp t values to correct speed

- SpeedFromHalfLife / HalfLifeFromSpeed

- ConvergenceTime — time to reach 90%, 99%, etc.

Editor Window (Window > DAWG Tools > Smooth Inspector)

- Three modes: Exponential, Spring, Ease

- Exponential: side-by-side graph of naive lerp vs Smooth.Exp at different frame rates

- Spring: response curve visualization showing overshoot for bouncy settings

- Ease: curve shape preview for all easing functions

- dt profile stress test (constant FPS, jittered frame times, FixedUpdate simulation, custom tick rates)

- Convergence analysis, migration helper, copy-to-clipboard snippets

EXAMPLES

Camera follow:

// Before (frame-rate dependent)

transform.position = Vector3.Lerp(

transform.position,

target.position,

followSpeed * Time.deltaTime

);

// After (consistent at any FPS)

transform.position = Smooth.ExpHalfLife(

transform.position, target.position,

0.15f, Time.deltaTime);

UI fade (works during frame drops and with timescale = 0):

canvasGroup.alpha = Smooth.ExpHalfLife(

canvasGroup.alpha, targetAlpha,

0.08f, Time.unscaledDeltaTime);

Rotation (no snapping at 0/360 boundary):

currentYaw = Smooth.ExpAngle(

currentYaw, targetYaw,

Smooth.SpeedFromHalfLife(0.12f),

Time.deltaTime);

Spring motion:

position = Spring.Critical(

position, target,

ref velocity, 5f,

Time.deltaTime);

Easing:

float t = elapsed / duration;

float eased = Ease.OutCubic(t);

value = Mathf.LerpUnclamped(start, end, eased);

Technical Details

• Unity 2021.3 LTS or newer
• Built-in, URP, and HDRP compatible
• Editor-focused tool (no runtime dependencies required)
• Clean namespace: DawgTools.OKLab
• Implementation follows Björn Ottosson’s reference specification
• Contrast computed using correct linear RGB luminance

Runtime Integration

At runtime, simply replace:

Color.Lerp(a, b, t);

With:

OKLabColor.Lerp(a, b, t);

Use perceptual interpolation only where it matters — UI transitions, theme blending, animated color states.

Designed For

• UI animation systems
• Theme engines
• Accessibility-conscious projects
• Design-heavy applications
• Production workflows requiring visual consistency

License

Licensed under the Unity Asset Store EULA.

DAWG Tools - OKLab Color Inspector PRO - Perceptual Color Tools for Unity

Unity’s default Color.Lerp interpolates colors in RGB component space.

https://dawgtools.org/unity/

For UI and theme transitions, this often results in:

• Desaturated or “dirty” midpoints
• Perceived brightness dips
• Unintended hue shifts
• Inconsistent animation quality

The OKLab color space is designed so that distance and interpolation better match human perception.

This tool makes the difference visible, measurable, and actionable inside the Unity Editor.

OKLab interpolation produces smoother, visually consistent gradients and transitions because it operates in a perceptual color space rather than raw RGB component space.

Instead of guessing how a transition will look, you can:

• Compare Gamma RGB vs Linear RGB vs OKLab interpolation
• Inspect perceptual midpoints
• Measure ΔE distance between colors
• Validate contrast compliance before shipping

1. Typical Workflow

1. Select two UI colors (e.g., Normal → Hover).
2. Compare Unity RGB interpolation against OKLab interpolation.
3. Inspect midpoint, hue drift, chroma, and contrast.
4. Replace Color.Lerp with OKLabColor.Lerp in runtime code.

2. Who It’s For:

• UI / UX engineers
• Technical artists
• Tools programmers
• Teams implementing dynamic themes
• Developers who care about visual polish and accessibility

3. WHAT'S INCLUDED

Interpolation Comparison

Side-by-side preview of:

• Unity RGB (Gamma)
• Linear RGB
• OKLab interpolation

Instantly see how transitions differ visually and mathematically.

Perceptual Metrics

• ΔE (perceptual distance measurement)
• Live midpoint inspection
• Chroma comparison
• OKLab component breakdown (L, a, b)
• Hue angle visualization

Accessibility & Contrast Tools

• WCAG contrast ratio calculation
• AA / AAA / Large-text thresholds
• Automatic best-text color suggestion
• Contrast validation against background colors

Computed correctly in linear luminance space.

OKLab Utilities

• OKLabColor.Lerp runtime helper
• OKLab decomposition per color
• Copy helpers (Hex, OKLab values)
• Lock Lightness (L)Optional perceptual constraints:
  Lock Chroma (C)
  

ASSET LIST & POLYCOUNTS (TRIANGLES)

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

Tedy Bear ...2,510

Dinosaur ...2,042

Lion ...2,006

Bunny ...2,008

Elephant ...2356

Giraffe ...1,648

Penguin ...1,848

Duck ...1,116

Total assets: 8 

+ simple room props with Demoscene

Textures: None

Texture dimensions: N/A

Texture maps: None

Materials: Unity materials only (URP compatible)

Render Pipelines: Built-in, URP

A charming set of stylized low-poly plush toy animals, perfect for children's room scenes, casual games, and cozy environment props. Each character has a soft, rounded form inspired by classic stuffed toys.

Package Contents:

• 8 plush toy animal prefabs (Teddy Bear, Bunny, Lion, Dinosaur, Elephant, Giraffe, Penguin, Duck)
• Simple demo room with props
• URP compatible materials
• No textures required
• Demo scene included

Low Poly Train 11 Lowpoly 3d model It is best for use in games and other real time applications.

Model is built with great attention to details and realistic proportions with correct geometry. 

4k textures are very detailed so it makes this model good enough for close-up. 

Features:

•     Low Poly Train 11_ polys:13372, Tris:31494, Verts:17748
•     Map size HD ---diffuse,specular,height,Normal,occlusion
•     Model is correctly divided into main part and animation parts
•     Model completely unwrapped.
•     Model is fully textured with all materials applied.
•     Pivot points are correctly placed to suit animation process.
•     All nodes, materials and textures are appropriately named.

Number of textures: 13

Texture dimensions: 4096*4096

Polygon count [Draton]

Verts: 5,867

Faces: 5,668

Tris: 11,326

Rigs: Yes

UV mapping: Yes

Material types and texture maps: PBR

Draton 3d model

Verts : 5,867

Faces : 5,668

Tris : 11,326

• Navigation-first architecture

• Deterministic panel lifecycle management

• LRU-based panel caching and automatic reuse

• Safe panel eviction and recreation

• Screen and Modal panel support

• Navigation Anchors for hub-style navigation

• Runtime-enforced screen exclusivity

• Inspector-driven navigation setup

• Engine-agnostic Core architecture

• Unity uGUI adapter included

• Optional DOTween animation integration

• Automatic setup via editor menu

• Basic and DOTween sample scenes included

• Fully extensible and modular design

Advanced UI Framework is a navigation-first UI system for Unity, designed to provide deterministic behavior, explicit lifecycle control, and clean architectural separation.

Instead of treating UI as loosely connected GameObjects, this framework manages UI as a structured system with defined ownership, navigation history, and lifecycle rules.

Panels are reused automatically through an internal LRU cache, preserving state while allowing safe memory eviction when needed. Navigation Anchors enable predictable hub-style navigation flows, and runtime-enforced rules ensure only one Screen is active at a time.

The Core architecture is engine-agnostic and separated from the Unity adapter, allowing flexibility and long-term scalability. Navigation can be configured entirely through the Inspector using Panel Descriptor and Panel Action components, or controlled directly through code using the Navigator API.

This framework is designed for developers building production-ready projects who need reliable, maintainable, and scalable UI infrastructure.

Included:

• Basic usage sample

• Optional DOTween integration sample

• Automatic setup tools

• Full documentation

• Compatibility: Built-in Render Pipeline and URP
• Number of textures: 1
• Texture dimensions: 2048x2048 (Base Color only)
• Triangles: 432
• Vertices: 222
• Number of meshes/prefabs: 1 mesh, 1 prefab
• Rigging: No
• Animation count: 0
• UV mapping: Yes
• LOD information: No LOD
• Types of materials and texture maps: Unlit, Hand-Painted Diffuse (Albedo)
• Mesh Collider: Yes (1 collision mesh)

Bring rustic storage character to your game world with this stylized hand-painted barrel. Classic wooden stave construction with expressive brushwork and a fully hand-painted texture make this lowpoly prop an instant fit for any environment that needs authentic rural atmosphere.

Key Features:

• Stylized Design: Unique hand-painted look that stands out in any environment.
• Game-Ready: Fully optimized for real-time performance and mobile platforms.
• Ready-to-use: Prefab and Material are pre-configured for instant use.
• Simple Setup: Uses a single material with an Unlit-friendly texture for easy integration.
• Clean Topology: Professional-grade low-poly mesh with no overlapping UVs.

A versatile prop for farm storage areas, tavern interiors, RPG market stalls, or any project that calls for a well-crafted storage container with a handmade visual style.

Compatibility: Built-in Render Pipeline and URP

Number of textures: 1

Texture dimensions: 2048x2048 (Base Color only)

Triangles: 526

Vertices: 271

Number of meshes/prefabs: 1 mesh, 1 prefab

Rigging: No

Animation count: 0

UV mapping: Yes

LOD information: No LOD

Types of materials and texture maps: Unlit, Hand-Painted Diffuse (Albedo)

Mesh Collider: Yes (9 collision meshes)

Add everyday farm character to your game world with this stylized hand-painted bucket. Sturdy lowpoly form, expressive brushwork and a fully hand-painted texture make this prop a natural fit for any rural or village environment built for real-time use.

Key Features:

• Stylized Design: Unique hand-painted look that stands out in any environment.
• Game-Ready: Fully optimized for real-time performance and mobile platforms.
• Ready-to-use: Prefab and Material are pre-configured for instant use.
• Simple Setup: Uses a single material with an Unlit-friendly texture for easy integration.
• Clean Topology: Professional-grade low-poly mesh with no overlapping UVs.

A versatile prop for farm yards, village market scenes, RPG environments, or any project that calls for a well-crafted everyday tool with a handmade visual style.

* Downtown & Interior — Texture: 2048x2048, PNG format

* Armory — Vertex Color only (no texture maps)

* Average polygon count: Building Preset(700–3000 tris), Walls(2–300 tris), Doors(60–500 tris), Furniture(50–150 tris), Props(100–300 tris), Weapons(2K–21K tris per main body)

Cyberpunk Low Poly Bundle — Downtown + Interior + Armory

GYP Studios presents —

🔥 Get all three Cyberpunk Low Poly packs in one bundle and save $60!

Total value: $219.97 → Bundle price: $159.99 (Save 27%)

This bundle includes our most popular Cyberpunk asset packs at a discounted price. Build an entire Cyberpunk world — from the neon-lit streets to detailed interiors to a full modular arsenal.

All assets share a consistent Low Poly art style, making them fully compatible with each other and with other low-poly assets such as Synty Studios.

▶ What's Included ◀

🏮 Cyberpunk Downtown Pack Vol.1 — Low Poly ($89.99)

900+ high-quality prefabs — modular buildings, sidewalks, road props, SkyTrain rails, signs, video ads, signboard videos, and more. Includes 2 AAA demo scenes.

🏮 Cyberpunk Interior — Low Poly ($69.99)

980+ high-quality prefabs — modular walls, floors, furniture, vegetation, neons, blood splatters, and more. Includes 2 AAA demo scenes.

💥 Cyberpunk Armory Pack Vol.1 — Low Poly ($59.99)

180+ high-quality prefabs — pistols, rifles, shotguns, snipers, blades, drones, gadgets, grenades. Fully modular with vertex color–based materials (no textures required).

▶ How to Download ◀

⚠️ Important: This bundle does NOT contain the asset files directly.

After purchasing this bundle, visit each package page listed below, click "Add to My Assets," and you will be able to download them for FREE:

1. Cyberpunk Downtown Pack Vol.1 — Low Poly

2. Cyberpunk Interior — Low Poly

3. Cyberpunk Armory Pack Vol.1 — Low Poly

▶ Why Buy the Bundle? ◀

* Save $60 (27%) compared to buying individually

* Consistent art style across all three packs

* Build complete Cyberpunk environments — exterior, interior, and weapons

* Over 2,060 prefabs in total

* Ideal for FPS, TPS, RPG, top-down shooters, or any stylized sci-fi project

▶ Compatibility ◀

* Built-in Render Pipeline (Install-Package included in each pack)

* URP — Universal Render Pipeline (Install-Package included in each pack)

📢 Follow & Support

🎬 YOUTUBE | 💬 DISCORD | 🎨 ARTSTATION | ✉️ EMAIL

※ Discord is not monitored frequently. For faster support, please contact us via email — we'll respond as soon as possible.

OUR ADVANTAGES

🗃️ Detailed docs • 🛠️ Easy editor tools • 🎨 Reskin guide • ✨ Clean structure & code

Try a demo: .apk(android)

Document

Ignite Chain is a complete Ignis‑style burning puzzle template for Unity, designed to help you ship brain‑teasing minimalist puzzle games fast. Tap once, watch the fire travel along edges, and let the chain reaction burn every shape on screen.

This package includes polished core gameplay, an in‑editor level creator,5+ Themes included and clean, extensible C# code ready for reskinning and monetization.

Core Features:

• Edge‑burning mechanic
• Shapes burn along their outlines (rectangles, hexagons, circles, custom meshes) with glowing fire lines and sparks.
• 5+ Themes included

Smart chain reaction system

When a shape finishes burning, its spark automatically jumps to the nearest unburnt shape to continue the sequence.

One‑tap puzzle gameplay

Players tap a single point to start the fire and must plan how to burn all shapes in one move.

Progressive difficulty

Start with simple one‑shape puzzles and scale up to complex layouts with zigzags, crossings, and timing challenges.

Built‑In Level Editor

• In‑editor level creator to place shapes, scale, rotate, and test instantly.
• Save and load levels as ScriptableObjects or data files.
• Rapid iteration workflow: tweak, test, and balance puzzles directly in the Scene view.
• 30 Levels Built in.

Mobile‑Ready Template

• Optimized for portrait mobile gameplay with tap input.
• Easy hooks for AdMob/Unity Ads and IAP (no SDKs included, just clean integration points).
• Lightweight, optimized effects suitable for low‑end devices.
• Code & Architecture
• Clean, commented C# scripts (fire manager, burnable shapes, input, level loader).
• Data‑driven level system for hundreds of levels.
• Modular design to add new shape types, themes, or mechanics.

Art & VFX

• Minimalist shapes and line‑based burn visuals inspired by modern puzzle aesthetics.
• Configurable colors, gradients, and materials for quick reskins.
• Particle systems for fire, sparks, and completion feedback.

Just import the package, open the sample scene, and start creating your own burning puzzle worlds.

Font Change Notice:

Changed to Lilita One font since v1.2.0 (The font was changed to a more global and refined font)

Free fonts were used in the demo scenes. Please exercise caution before use.

• 343 Audios
• Number of Audio Waves: 343
• Format: 96KHz / 24 bits
• Do Sound FX loop: No
• Win/Mac: Yes
• Minutes of audio provided: 20:00

Universal Explosions is designed to provide a wide variety of explosions of all kinds.

The idea behind this series is to cover a full spectrum, from realistic explosions to more sci-fi and cinematic styles. In this release, we include 25 types of explosions, each with 4–6 variations, resulting in a total of 150 unique sounds.

Additionally, as with most of our sound libraries, almost all explosions include their elements separated (pre-hits, tails, etc.), allowing you to build and adapt each sound exactly to your project’s needs. Including these separated elements, the library offers over 150 sounds in total.

For this release, the sources are not yet included, but they will be available in the coming weeks. They will be offered separately at a different price, so if you only need the designed sounds, you won’t have to pay extra.

The library is built with a modular recombination approach, meaning many elements are provided in separate layers, allowing you to combine them freely like a puzzle.

Highlighted elements:

• Aerial Bomb Drop And Blast
• Big Fire Explosion
• Distant Growing Blast And Shockwave
• Distant Missile Impact And Explosion
• Distant Missile Impact And Fire
• Distant Multiple Successive Explosions
• Double Explosion With Reverberation
• Electric Sci-Fi Grenade Explosion
• Etc.

Technical specifications
Following Khron Studio’s quality standards, the library is delivered in high-resolution audio: 192 kHz / 24-bit.

More about the pack

• Intuitive file naming
• Use the sound effects over and over, in any of your projects or productions, forever without any additional fees or royalties. Use the SFX in your game, in your trailer, in a Kickstarter campaign, wherever you need to, as much as you want to.
• Totally mono compatibility
• All sounds have several variations.
• Use your imagination and feel free to use any sound for a creature other than the one described, remember that the world of sound is totally subjective.
• For any questions or problems: khronstudio@gmail.com

• Features:
• Vivox Voice and Text Chat
• Customizable UI using UIToolkit
• Test scenes setup to:
• Connect players to voice and text, display a roster of players with speaking indicators and mute capabilities, and send text messages.
• Manipulate input and output device selection and volume
• Supported OS: Windows, Mac
• Documentation Link:
• Vivox voice and text chat Building Block

The Vivox Building Block is designed for flexible, modular integration of voice and text communication in your Unity project. It’s customizable to fit your game, but also works out of the box.

This Building Block demonstrates how to do the following:

• Join a voice and/or text channel through the Vivox SDK.
• Create a roster displaying all players in a channel and their speaking status, with the ability to mute individual players.
• Create a text chat UI allowing players to retrieve message history and send messages to a channel.
• Create a device selection UI for adjusting input and output device selection and volume.

Number of Animations: 40

Animation Types: Root Motion/In-place

Important/Additional Notes: ⭕Models are not included in project only available Animations.

⭕Only Humanoid Animation available in Project

A collection of character animations including Oblivion, Death, and Last Breath animations. Each animation is designed with attention to detail, smooth transitions, and game-ready optimization, making them ideal for use in games, cinematics.

There are 20 different Set of Oblivions Animation.(40 Animations)

💬 Support

📧 nexaframeproduction@gmail.com

Number of unique meshes: 24
Number of prefabs: 24
Number of demo scenes: 2

Polygon count: 164 to 2000 triangles
Average polygon count: approximately 710 triangles per asset

Rigging: No
Animation: No
UV mapping: Yes
LOD information: No

Materials and textures: Standard Unity materials (color only, no textures)
Requirements: None (compatible with Built-in Render Pipeline, URP and HDRP)

This bundle contains the complete HS (Hors Série) standalone sci-fi collection, designed to build dark, high-contrast industrial environments and modular interior structures.
Combine industrial props, modular pipes, structural elements, walls, floors and vertical connectors into one unified system for building compact and readable sci-fi layouts.
All assets follow a distinct standalone visual identity with strong contrast and emissive accents, allowing seamless integration between both packs.
Clean, optimized meshes — ready for real-time production.

📦 Included Packs

HS-001 Industrial Props Pack
HS-002 Modular Environment Pack

✨ Features

Complete standalone industrial and modular system
Designed for compact and vertical level design
High-contrast visual style with emissive accents
Distinct blue-toned lighting identity
Game-ready optimized meshes
No textures — material color workflow

Number of unique meshes: 12
Number of prefabs: 12

Polygon count: 164 to 2000 triangles
Average polygon count: approximately 948 triangles per asset

Rigging: No
Animation: No
UV mapping: Yes
LOD information: No

Materials and textures: Standard Unity materials (color only, no textures)
Requirements: None (compatible with Built-in Render Pipeline, URP and HDRP)

Low Poly Sci-Fi Modular Environment Pack HS-002
This pack contains 12 stylized low-poly sci-fi modular assets designed to build complete interior structures, corridors and vertical layouts with a dark high-contrast atmosphere.
It includes walls, floors, stairs, doors and structural connectors, allowing you to create clean modular environments with strong assembly logic and clear readability.
All assets are optimized for performance and designed for easy integration into game levels, making the pack suitable for space corridors, industrial hubs, arenas, prototypes and full productions.

Key Features:

12 low-poly sci-fi modular environment assets
Walls, floors, stairs, doors and structural connectors included
Designed for vertical level building and modular assembly
Cool blue emissive lighting with strong contrast
Clean stylized low-poly design with strong readability
No textures — material color workflow (easy to customize)
Optimized for game performance

Pack Content:

Modular walls, floors, stairs and connectors designed to build structured sci-fi interiors and scalable environments with a distinct visual identity.

Number of unique meshes: 12
Number of prefabs: 12

Polygon count: 244 to 840 triangles
Average polygon count: approximately 471 triangles per asset

Rigging: No
Animation: No
UV mapping: Yes
LOD information: No

Materials and textures: Standard Unity materials (color only, no textures)
Requirements: None (compatible with Built-in Render Pipeline, URP and HDRP)

Low Poly Sci-Fi Industrial Pack HS-001
This pack contains 12 stylized low-poly sci-fi industrial assets designed for darker technical environments, maintenance zones and modular utility areas.
It includes crates, pylons, fuel barrels, control panels, turrets and a complete modular pipe system, allowing you to quickly build compact industrial layouts with strong visual contrast and clear functional design.
All assets are optimized for performance and designed for easy integration into game levels, making the pack suitable for industrial scenes, sci-fi corridors, RTS, prototypes and full productions.

Key Features:

12 low-poly sci-fi industrial assets
Crates, pylons, fuel barrels, control panels, turret and pipe system included
Modular pipe elements (straight, corner, cross, T)
Dark high-contrast visual style with emissive accents
Clean stylized low-poly design with strong readability
No textures — material color workflow (easy to customize)
Optimized for game performance
Compatible with Unity, Unreal, Godot and Blender

Pack Content:

Industrial props and modular pipe elements designed to build structured, high-contrast sci-fi environments and utility zones.