Asset Store newest packages

Asset List & Polygon Counts (Triangles)

• City_CompactCar — 1,242
• City_DeliveryVan — 1,156
• City_MiniCar — 1,142
• City_PoliceCar — 1,322
• City_Taxi — 1,454
• Construction_Bulldozer — 1,264
• Construction_CementMixer — 1,634
• Construction_CraneTruck — 1,388
• Construction_Excavator — 1,388
• Construction_RoadRoller — 1,032
• Service_BoxTruck — 1,364
• Service_DumpTruck — 1,424
• Service_GarbageTruck — 1,562
• Service_PickUp — 1,260
• Special_Ambulance — 1,260
• Special_Camper — 1,446
• Special_FireTruck — 1,946
• Special_Tractor — 1,706

Textures & Materials

• No textures included
• Uses Unity materials only (URP compatible)
• Fully color-customizable via material inspector

A stylized toy vehicle pack for casual and mobile games.

Includes multiple city, construction and emergency vehicles with easy-to-edit materials and prefab-ready setup.

Unique Meshes: 42

UV Mapped: Yes

Texture Resolution: 2k

Prefabs: 45 prefabs. Many pieces are modular and can be combined, assembled, or colored/textured different ways.

Polygon Count:

• Total for whole pack: 9,656
• Truck: 1,734

Materials: Textures and UVs, Standard unity shaders.

Poke Man – Hawaiian Food Truck

Bring island vibes to your game with Poke Man, a fully featured stylized Hawaiian poke food truck. Perfect for beach scenes, festivals, markets, towns, or casual environments, this pack includes a highly detailed truck, interior props, signage, and a flexible string lights system to add instant atmosphere.

Key Features

• Stylized Hawaiian-themed food truck with custom textures and branding
• Detailed service window interior with food prep props
• Procedural String Lights Tool (no rope mesh required)
  Inspector-driven anchor placement
  Adjustable spacing, sag, colors, and emissive intensity
  Optional visible string (LineRenderer-based)
  Reusable for festivals, markets, camps, and more
• Consistent Unity-scale modeling (1 unit = 1 meter)
• Optimized for performance and easy scene setup
• Works great for environment dressing or gameplay scenes

Included Props & Assets

• Poke Man food truck (exterior + interior)
• A-frame chalkboard menu sign
• POS terminal screen
• Rice cooker with custom display
• Bottles (soy sauce, sesame oil, spicy sauce)
• Cutting board, knife, bowls, rice, poke food props
• Cooler, trash can, countertop items
• Surfboard and beach accessories
• Palm trees and environmental dressing
• Modular string lights with bulb prefabs
• Stylized textures and screen graphics

String Lights Tool

The included String Lights Tool allows you to quickly add customizable hanging lights to your scene:

• Place anchor points directly in the scene
• Automatically generates evenly spaced bulbs
• Built-in sag simulation for natural droop
• Per-bulb emissive color variation
• Optional point lights for night scenes
• Ideal for food trucks, beach bars, markets, and festivals

This system is reusable across any scene and adds instant warmth and character.

✅ 18 Breakable Stylized Wooden Props – Fully destructible objects for interactive gameplay.

✅ Realistic Physics-Based Destruction – Objects break apart dynamically upon impact or explosion.

✅ Dynamic Explosion System – Adjustable explosion force and radius for varied destruction effects.

✅ Automatic Fragment Cleanup – Optimized fade-out effect to remove debris and improve performance.

✅ Easy Integration – Drag, drop, and trigger destruction with a simple script call.

✅ Customizable Settings – Adjust explosion power, fade-out duration, and fragment removal time.

✅ Debug Gizmos – Visualize explosion radius for precise tuning.

✅ Supports Multiple Pipelines – Compatible with Built-in, URP, and HDRP render pipelines.

✅ 2K PBR Textures – High-quality materials for realistic visuals.

✅ Optimized for Performance – Low-impact on frame rate with efficient physics handling.

Perfect for action, survival, FPS, and simulation games needing immersive destructible environments!

✅Maximum polygon count - 3,488 - Minimum polygon count - 132

Breakable Stylized Wooden Pack provides highly optimized, game-ready, and easy-to-use destructible wooden props. With 18 ready-to-use prefabs featuring realistic physics-based destruction, this pack is perfect for action, adventure, survival, and FPS games.

The system allows customization with adjustable explosion power, fade-out effects, and automatic fragment cleanup, ensuring smooth performance in dynamic environments. The package supports Built-in, URP, and HDRP render pipelines, making it compatible with various projects.

If you're interested with breakable props, be sure to check out our Asset Store page for more!

For any question or support :

Email : contact@satproductions.com

Discord : Join our Discord

⚙️ Technical Features

• GPU compute driven wave simulation
• Ocean/Lake mesh with LOD rings
• Shared simulation across multiple bodies
• GPU to CPU height readback (optional)
• Zone Painter tool for damping & transitions
• Analytic & SDF-based water volumes
• Runtime-friendly API for buoyancy & queries

📘 Documentation 🕹️ Compatibility 💬 Support (support@eugatnomstudios.com)

A license for this asset guarantees access to updates for Unity 2022-2023 & Unity 6.0–6.3 and future improvements within the Tidal product line.

What is Tidal?

Tidal is a GPU-accelerated water system for Unity URP, built around FFT-based wave simulation, clipmapped ocean meshes, and modular subsystems. It is designed for oceans, lakes, pools, and large-scale water bodies, with a strong focus on performance, flexibility, and editor tooling.

Tidal is intended for developers who want real control over wave behavior, performance scaling, and runtime interaction, rather than a one-size-fits-all water shader.

🌊 Highlights

• FFT-based multi-cascade wave simulation (GPU compute)
• Profile-driven wave behavior (wind, fetch, swell, direction)
• Infinite oceans and bounded lakes
• GPU height readback for buoyancy & gameplay
• Optional planar reflections
• Underwater rendering & depth fog
• Zone-based damping and transitions
• Extensive editor tooling and validation

🏄 Quick Overview

Tidal separates simulation, rendering, and interaction into clear components:

• TidalCompute - FFT wave simulation (can be shared across bodies)
• TidalBody - Rendering, mesh LODs, subsystems
• TidalSurface Material - Visual appearance
• TidalProfile - FFT water settings (as Scriptable Object)
• Zones & Volumes - Damping, masking, clipping, and interaction control

This modular design allows multiple water bodies to share a single simulation for excellent performance scalability.

💧 Rendering & Visual Features

• FFT-based displacement with 3 cascades
• Shoreline & surface foam
• Subsurface scattering
• Environment reflections
• Optional planar reflections
• Underwater fog & lighting sync
• Orthographic camera support
• Day/night & emissive reflection support

📦 Demo scenes/content

• Extreme wave / tsunami scene
• Large-scale oceans and island scene
• Indoor & confined water scene
• Multi-body scene
• Orthographic camera scene
• Performance-focused configuration scene
• Example profiles & materials
• Editor validation and setup helpers

✔️ Platform Support

Fully Supported:

• Windows (DX11 / DX12) - Primary development and tested platform

May Work: (Untested / Limited)

• macOS
• iOS / Android
• Consoles
• VR

Not Supported:

• WebGL - Compute shaders required

⚡ Performance

Tidal is designed to scale:

• Share one simulation across many bodies
• Reduce FFT resolution
• Lower simulation update rate
• Disable planar reflections or underwater rendering
• Adjust mesh LOD density

From calm lakes to massive oceans, performance is always under your control.

📘 Documentation

Full setup guides, inspector references, performance tips, and demos:

https://eugatnomstudios.com/tidal/doc/

Third-Party Content

This asset includes third-party components licensed under permissive open licenses:

• Assets from Poly Haven and AmbientCG, licensed under Creative Commons CC0 1.0 Universal
• 3D models by Kenney, licensed under Creative Commons CC0 1.0 Universal
• Code and mathematical techniques derived from FFT-Ocean by Ivan Pensionerov, licensed under the MIT License

Promotional Media Notice:

Some promotional screenshots on the Asset Store page use a skybox from the Fantasy Skybox FREE package by Render Knight. This skybox is used for visual presentation only in screenshots and is not included, redistributed, or required for use of this asset. Permission for this usage has been granted by the asset author.

See the included Third-Party Notices.txt file in the package for full license details.

• Resolution: 8192×4096
• Format: HDR / EXR
• Map Type: Equirectangular
• Seamless: Yes
• Number of Skyboxes: 11
• Texture Type: Skybox / HDRI

Cinematic Inferno Skies – 8K Fire & Volcanic Skybox Pack

Cinematic Inferno Skies is a collection of high-detail fractal skybox environments designed to add dramatic atmosphere and scale to your scenes.

This pack includes 11 unique 8K skyboxes featuring inferno clouds, volcanic energy formations and fiery atmospheric effects suitable for fantasy, sci-fi and apocalyptic settings.

🔥 Features

• 11 unique cinematic skyboxes
• 8K resolution (8192×4096)
• Seamless equirectangular panoramas
• High dynamic range lighting
• Strong cinematic contrast
• Ready for real-time rendering

🎮 Ideal For

• Fantasy games
• Sci-fi environments
• Dark worlds
• Apocalyptic landscapes
• Cinematic backgrounds
• Stylized projects

Mobile Camera Texture is a high-performance Unity asset that lets you render a native mobile camera session directly onto a Unity Texture with minimal latency and full hardware acceleration.

It is built for production use and provides deep access to platform-specific camera controls through a clean and developer-friendly API.

MCT is ideal for AR, computer vision, live camera effects, custom camera pipelines, and any application that requires fast, reliable camera preview rendering inside Unity.

🧩 Try the free watermarked version it includes all features, allowing you to fully test the asset before purchasing.

Key Features

High-Performance Camera Rendering

• Native, hardware-accelerated camera preview
• Extremely low latency
• Uses platform camera surfaces for optimal performance
• Supports OpenGLES 2, OpenGLES 3, and Vulkan

Wide Android Architecture Support

• ARMv7
• ARM64
• x86
• x86_64

Flexible Rendering Targets

Render live camera output directly to:

• Unity UI elements (RawImage)
• 3D objects (MeshRenderer)

Advanced Camera Control

Access most features of the Android Camera2 API, including:

• Exposure
• Focus
• White balance
• Additional controls (device-dependent)

Developer-Friendly Workflow

• Prefab-safe components
• Inspector-based configuration
• Clean, extensible runtime API
• Easy integration into existing Unity projects

❗ Important Notes ❗

Unity Editor Limitation

• Camera rendering works only in built applications
• Live camera preview is not available in the Unity Editor

Platform Support

• Android only
• Minimum Android API level: 22 (Android 5.1)

Rendering Backends

OpenGLES 2 / OpenGLES 3

• Hardware-accelerated rendering requires Android API 22+

Vulkan

• Supported on Android API 28+
• Hardware acceleration requires Android Hardware Buffer (AHB) import support
• If AHB is unavailable, MCT automatically falls back to a pixel-copy rendering path

Support & Contact

If you need technical support, encounter a bug, or have feedback or feature suggestions, feel free to get in touch:

📧 quantumrenderlab@gmail.com

Technical Highlights

Unity 2021.3+ compatible

TextMeshPro integration (included in Unity)

Optional Input System support (gracefully handles both old and new input)

Singleton architecture with scene persistence

Event-driven design for easy integration

Sample scenes included for quick learning

Transform Your User Experience with Professional Guided Tutorials

The Guided Tutorial Tool is a complete, ready-to-use solution for creating guided tours, onboarding experiences, and interactive tutorials in Unity. Build polished, step-by-step walkthroughs without writing a single line of code—everything is configured directly in the Unity Editor.

Why Choose Guided Tutorial Tool?

🚀 Zero-Code Solution Create entire tutorial flows using the Unity Inspector

No programming knowledge required

Visual configuration for every aspect of your tours

⚡ Save Development Time Pre-built system eliminates weeks of custom development

Focus on your game, not tutorial infrastructure

Tested and production-ready out of the box

🔌 Completely Decoupled Tutorial logic is separate from your game code

No dependencies on your existing systems

Easy to add or remove without affecting other features

🌐 Universal Platform Support Works seamlessly on Mobile (iOS, Android)

Perfect for Desktop (Windows, Mac, Linux)

Fully compatible with WebGL builds

Supports all Unity render pipelines (Built-in, URP, HDRP)

Powerful Features

✨ Visual Highlighting Highlight UI elements with customizable cutouts

Support for 3D world-space object highlighting

Shaped masks using sprite alpha channels

Animated pointer indicators

💬 Rich Dialog System Multiple text animation effects (Typewriter, FadeIn, Scramble, WaveReveal)

Customizable dialog positioning and styling

Flexible end conditions (time-based, click, animation end, manual)

Skip functionality for optional steps

🎯 Flexible Task Management Mix highlight and dialog tasks in any sequence

Conditional task progression

Persistent progress saving

Resume tours from where players left off

🌍 Localization Ready Integrate with any translation system

Template-based translation provider

Support for multiple languages

⚙️ Fully Customizable Every visual element is configurable

Extensible architecture for advanced users

Event system for custom integrations

Complete API for programmatic control

Perfect For

Game Onboarding - Guide new players through your game mechanics

Feature Tutorials - Showcase new features and updates

Software Training - Create interactive walkthroughs for applications

UI Demonstrations - Highlight interface elements and controls

Marketing Demos - Create engaging product showcases

Get Started in Minutes

Import the package

Create a Tour Manager via the menu

Create your first Tour

Configure tasks visually

Play and test immediately

Complete documentation and sample scenes included to get you up and running fast.

• Works with any character model using Skinned Mesh Renderers and Blendshapes.
• Supports multiple meshes per animator (e.g., separate meshes for eyes, teeth, or hair).
• Full support for Unity’s AudioSource system.
• Includes custom, modern Editor Inspectors for a clean workflow.

Blendify: Facial Animation & Dialogue System

Bring your characters to life with a single click.

Blendify is a powerful, lightweight, and artist-friendly toolkit for Unity that automates facial expressions and lip-syncing. Whether you are building a narrative-driven RPG, an interactive VR experience, or cinematic cutscenes, Blendify removes the tedious work of manual blendshape keyframing.

Key Features

One-Click Auto-Setup: Skip the manual labor. Our intelligent scanning system automatically detects your mesh’s blendshapes and maps them to phonemes and expressions instantly.

• Intelligent Lip-Sync: Driven by DialoguePresets, the system synchronizes mouth movements to text and audio with customizable speed and intensity.
• emotion Procedural Expressions: Smoothly transition between emotional states (Happy, Sad, Angry, etc.) with adjustable fade times for natural facial performances.
• Natural Blinking System: A built-in procedural blinking engine that adds life to your characters using randomized intervals and durations.
• Dialogue Sequencing: Chain multiple dialogue lines into complex sequences with the DialogueSequencePlayer. Control delays, expression changes, and trigger logic without writing code.
• UI Integration: Built-in support for linking dialogue to UI buttons and a ready-to-use Audio Volume system for sliders and mute toggles.
• Editor Power Tools: Test expressions and play dialogue directly in the Inspector during edit mode. Use the Global Validator to ensure your character is perfectly configured.

Why Choose Blendify?

• Workflow Optimized: Designed for developers who need high-quality facial animation without the complexity of external software or expensive MoCap.
• Highly Extensible: Clean, documented C# source code that is easy to integrate into your existing gameplay systems.
• Performance First: Efficiently handles mesh weight updates with minimal CPU overhead, making it suitable for both Desktop and Mobile/VR platforms.
• Artist Friendly: No coding required for basic setup. Uses standard ScriptableObjects for dialogue data management.

Technical Details

• Works with any character model using Skinned Mesh Renderers and Blendshapes.
• Supports multiple meshes per animator (e.g., separate meshes for eyes, teeth, or hair).
• Full support for Unity’s AudioSource system.
• Includes custom, modern Editor Inspectors for a clean workflow.

• Developed using Unity 6000.0.59f2.
• The asset relies only on standard Unity components and classes, with no third-party dependencies required.

Full Documentation: DevFlow Documentation

Discord: DevFlow Community

DevFlow 💻 is a productivity and workflow enhancement tool for Unity developers.

It helps you stay focused and manage development sessions directly inside the Unity Editor.

With a clean UI, Pomodoro timer, and focus management features, DevFlow turns your Editor into a smart productivity hub.

Key features:

• Built-in Pomodoro Timer - balance work and rest efficiently right inside Unity.
• Notifications & Progress Display – stay aware of your current session without distractions.
• Productivity Insights – measure focus time to optimize your development rhythm.
• Lightweight & Editor-native – runs entirely in the Unity Editor with minimal overhead.

Purpose:

Boost your development efficiency by integrating focus management and time tracking directly into your workflow.

Perfect for solo developers, small teams, and anyone aiming to improve consistency, discipline, and productivity inside Unity.

Pixel Shooter 3D – Jam Template + Editor is a complete game development template, designed for creating and customizing pixel-style 3D shooter games similar in structure and gameplay to popular hyper-casual shooters.

It includes a full gameplay loop, destructible block systems, player and powerup mechanics, and a fully featured in-game level editor with JSON import/export support. All systems are modular, data-driven, and easy to extend, making this template ideal for game jams, prototypes, and production-ready casual or hyper-casual games.

Try First: Browser Demo | Android Demo

Browser Level Editor Tool

OUR ADVANTAGES

Developer-oriented architecture

Clear documentation and setup workflow

Built-in level editor and editor utilities

Easy visual, color, and gameplay customization

Clean, modular, and extendable Unity codebase

TEMPLATE INCLUDES

🔫 Pixel Shooter Gameplay

‎ ‎ ‎ ‎ - Pixel-style 3D shooter mechanics

‎ ‎ ‎ ‎ - Destructible block system with visual feedback

‎ ‎ ‎ ‎ - Player deck and ammo-based progression

‎ ‎ ‎ ‎ - Shooting, homing bullets, and conveyor-belt movement

‎ ‎ ‎ ‎- Multiple player states and powerup modes

🏗️ Level Editor & Data System

‎ ‎ ‎ ‎ - Built-in in-game level editor scene

‎ ‎ ‎ ‎ - Grid-based block placement and removal

‎ ‎ ‎ ‎ - Player deck and color configuration per level

‎ ‎ ‎ ‎ - JSON level export and import system

‎ ‎ ‎ ‎ - ScriptableObject-based level data support

🎮 Powerups & Player Systems

‎ ‎ ‎ ‎ - Modular player (Pig) controller with state machine

‎ ‎ ‎ ‎ - Super Player / Super Pig powerup mode

‎ ‎ ‎ ‎ - Tray and hand-picker gameplay modes

‎ ‎ ‎ ‎ - Extendable powerup architecture

🎨 Color & Visual Tools

‎ ‎ ‎ ‎ - Advanced block colorizer system

‎ ‎ ‎ ‎ - Image-based color extraction

‎ ‎ ‎ ‎ - Automatic color clustering using K-Means algorithm

‎ ‎ ‎ ‎ - Easy replacement of materials, models, and effects

🧪 Developer & Debug Tools

‎ ‎ ‎ ‎ - Debug helpers for testing gameplay

‎ ‎ ‎ ‎ - Modular GameManager architecture

‎ ‎ ‎ ‎ - Clean namespace isolation (PixelShooter3D)

🎨 Customization Friendly

‎ ‎ ‎ ‎ - Easily replace visuals, UI, and animations

‎ ‎ ‎ ‎ - ScriptableObject-driven configuration

‎ ‎ ‎ ‎ - No hardcoded gameplay rules

‎ ‎ ‎ ‎ - Designed as a foundation, not a locked system

💿 Supported Platforms

‎ ‎ ‎ ‎ - iOS

‎ ‎ ‎ ‎ - Android

‎ ‎ ‎ ‎ - WebGL

‎ ‎ ‎ ‎ - Desktop

📄 Documentation

Includes step-by-step guides for:

• Setting up the game and editor scenes

• Creating and editing levels

• Exporting and importing JSON level files

• Customizing player behavior and powerups

• Extending the template for your own shooter game

📬 Support

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

📧 Email: ragendom@gmail.com

Requires Save for Unity Core

NOTE: This asset is distributed as Plugin dll's. No source code is provided.

Adds support for Scriptable Objects to the Save for Unity Core system

Want to know more?

Read the Documentation | Discord | Email | Website

This Core asset will serialize/deserialize the following

GameObject

Transform

Serializable Structs and Classes

as well as

C# Primitives

.Net Collections

Common Unity structs such as Vectors, Quaternion, Colors etc

See documentation for a complete list.

NOTE: This asset is distributed as Plugin dll's. Only example source code is provided.

Saving and Loading data should be easy and simple, fast, safe and secure, often it is not!

Whatever you need to save call Save.method() and let our custom binary serializer do the rest. No setup, no fuss. Bringing it back is as simple as Load.method() We have done the hard work so you don't have to.

Our simple to use API let's you save what you want in just 2 lines of code and if you don't want to code we supply No Code options for Saving and Loading.

Want to save your procedurally generated world? No problem, we save both values and references so nothing gets lost.

GameObjects, Components, Monobehaviours, Primitives, Structs, Classes, .Net Collections, Key Value pairs, ScriptableObjects, we have it covered. See technical details for more information.

Easy. Fast. Efficient. Secure.

Synchronous or Asynchronous saving and loading, compression by default, bring your own encryption if required.

Save/Load using a file for local storage or a Steam for online.

Our modular add-on system means you only have the overhead for the things your project needs. Need more? Add a module. Need less? Delete a module, it's that simple.

The ONLY Complete Save and Load Data System on the market

Despite the claims of others no one comes close to serializing the range of data types supported by the Save for Unity system. More Primitives and C# objects. More .Net Collections. More than 200 Unity objects. All 'out of the box'.

Because WE do NOT rely solely on Reflection for serialization (unlike other well known save/load systems), we will always be the Ultimate Solution for saving and loading your data in terms of ease of use, speed, I/O size and coverage.

Network Support

This edition of the Core module includes support and server examples for TCP, HTTP and UnityWebRequest network saving and loading.

Why Binary Serialization matters to YOU?

String based serializers (JSON, XML, YAML etc) are slow and create large data files with lots of garbage to be collected. Binary serializers however create small data files faster with little or no garbage collection. Smaller data files mean less system IO which translates into faster save and load times. Binary deserialization means no string parsing increasing speed whilst decreasing overhead. See our performance comparison tests here

Still not convinced? This edition supports JSON saving and loading so you can test the difference.

Optimization Built in

Here at SteveSmith.Software we care about YOUR project performance. Our unique optimization utility will remove the usage of Reflection during serialization (improving save and load times by over 20%) and remove any unused code (reducing build times and the load time of your finished game)

Want to know more?

Read the Documentation | Discord | Email | Website

SteveSmith.Software offers multiple solutions for your data requirements. See our product comparison chart, above, to decide which one best fits you and your project.

• 78 Blendshapes/Morphs (52 blendshapes for Unity Face Capture and 23 blendshapes for Phenomes, 03 elve ear blenshapes)
• Male and Female character rigged with same skeleton (UE5 Manny simple skeleton with 02 extra bones clavicle_pec_r and clavicle_pec_l)
• Male and Female head same scale so you can share Hair/Hat
• Blending/Mixing color/textures on Materials
• Makeup Face/Hair/Eyes/Lips
• Cloth and Jiggle physic setup ready

Number of textures: 89

Texture dimensions: 2048 -4096

Polygon count of [Model Name]: 70k -150k

Minimum polygon count: 70k

Maximum polygon count: 150k

Number of meshes/prefabs: ~6

Rigging: Yes

Animation count: 0

Animation type list

UV mapping: Yes

LOD information (count, number of levels): No

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

Dear my friends,

After a period of experiencing the default physics simulation tools and various free tools, I have realized that the physics simulation needs improvement to provide a better experience for users. For this reason, I have decided to use Magica Cloth 2.

If you do not use Magica Cloth 2, you can still utilize the character; however, you will need to set up the physics simulation for the cloth and hair using your own tools.

Please note that to activate the physics simulation for the character, you will need Magica Cloth 2. Kindly follow the instructions below to proceed with the activation:

Active Magica Cloth 2 on characters

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

Character overview:

The Healer class is typically composed of characters specialized in healing and supporting teammates in fierce battles. With mending and restorative abilities, Healers play a crucial role in maintaining the group's strength, keeping allies alive, and enhancing their combat effectiveness. They often possess skills for health restoration, damage absorption, and even shielding comrades from dangers. Healers are commonly seen as the heart of the team, providing stability and protection for all members, while playing a vital role in completing missions and achieving victory in the power struggle of the virtual world.

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

How to use

• N5 Character Guidelines
• How to using Unity Face Capture
• The characters in the package utilize the Dawnshader_SG shaders created with Shader Graph in Unity. The package is set up in HDRP mode, if you wish to use them in URP or Built-in, you can switch the SRPs without changing the shaders, although you may need to readjust lighting and environment settings. Additionally, you may need to fine-tune the skin materials or other materials for optimal results. You may also need to install Shader Graph in Unity to modify the shader and follow the steps below:

Window -> Package Manager. Shader Graph

• To avoid get error log "inputValue" so please following:

Window -> Package Manager. At the top left corner of that window you should change: Packages: In Project >>> Packages: Unity Registry. Search for Input System and install. Restart project >> Done

• You should open Overview scene to find out features of character package
• You can find Face Morphs/Blendshapes on Head Morphs in this package.
• Feel free to learn more about characters and make a questions on my [My Discord]

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

All character body parts are modular so you can mix with my other N5 characters same gender but make sure you have scripts to mix characters, this package not included mixing character scripts.

Props physic on character clothes setup physic ready with demo script of Dynamic Bone

This character has over 78 Blendshapes/Morphs (52 blendshapes for Unity Face Capture and 23 blendshapes for Phenomes. 03 elve ear blenshapes), 01 hair styles

Technical details:

   Bidirectional conversion: BiRP → URP → HDRP (any direction)

   150+ built-in shader mappings with property transformations

   Project scanner with automatic pipeline detection

   Confidence-based material categorization (High/Medium/Low)

   Batch conversion with progress tracking

   Smart property mapping (_Color → _BaseColor, _MainTex → _BaseMap, etc.)

   Shader keyword preservation (_NORMALMAP, _EMISSION, _ALPHATEST)

   Render queue and GPU instancing settings preserved

   Automatic material backup system

   Full Undo/Redo support

   HTML report generation with visual statistics

   Folder-specific scanning and conversion

   Material filtering by shader, confidence, source pipeline

   Editor window with 5 tabs: Overview, Materials, Shaders, Lighting, Settings

   C# API for custom automation workflows

   Zero runtime overhead (Editor-only tool)

   Unity 2021.3+ compatible

Pipeline Forge is the ultimate material conversion solution for Unity developers. Seamlessly migrate your projects between Built-in (BiRP), Universal (URP), and High Definition (HDRP) render pipelines.

  KEY FEATURES:

   Bidirectional Conversion - Convert materials in any direction: BiRP ↔ URP ↔ HDRP

   150+ Shader Mappings - Standard, Particles, Terrain, SpeedTree, Skybox, UI, Sprites, Legacy

   Intelligent Property Transfer - Automatic color, texture, and value mapping

   Keyword Preservation - Normal maps, emission, alpha cutout, transparency maintained

   Batch Processing - Convert entire projects or folders with one click

   Detailed HTML Reports - Visual breakdown of conversion results

   Non-Destructive - Automatic backups with full Undo support

   Clean Editor UI - Professional interface with filtering, search, and progress tracking

  SUPPORTED SHADERS:

   Standard / Lit (PBR materials)

   Particles (Surface, Unlit, Additive, Alpha Blended)

   Terrain shaders

   SpeedTree 7 & 8

   Skybox (Procedural, 6-Sided, Cubemap, Panoramic)

   UI & Sprites

   Legacy shaders (Diffuse, Specular, Bumped, Transparent)

   Unlit shaders

  PERFECT FOR:

   Upgrading legacy BiRP projects to URP/HDRP

   Cross-platform development (mobile URP, console HDRP)

   Asset developers maintaining multi-pipeline compatibility

   Studios migrating large codebases

• Fully Procedural Voxel World Generation
  Chunk-based voxel terrain with configurable size, height, seed, and render distance.
• Dynamic Chunk Streaming System
  Automatic loading, unloading, and rebuilding of chunks based on player position.
• Advanced Terrain Generation
  Multi-layer Perlin noise terrain with hills, plains, beaches, rivers, and lakes.
• Real-Time Water Simulation
  Minecraft-like voxel water with:
  Water sources and flow levels
  Falling and horizontal spreading
  Dynamic updates when blocks are placed or removed
  Optimized update queue system
• Rivers & Lakes Generation
  Procedural rivers and lakes with adjustable width, depth, and frequency.
• Voxel Mesh Optimization
  Face culling (only visible faces rendered)
  Separate submeshes per block type
  32-bit index buffers for large meshes
• Distance-Based Collider Optimization
  Mesh colliders enabled only near the player to improve performance.
• Multiple Block Types Support
  Grass, Dirt, Stone, Sand, Water, Wood, Leaves, Bedrock — easily extendable.
• Dynamic Terrain Editing (Runtime)
  Place and remove blocks at runtime with automatic mesh and water updates.
• Procedural Trees Generation
  Configurable tree density, height, and shape.
• Smooth Water Surface Rendering
  Per-vertex water height calculation for natural-looking water surfaces.
• Material-Based Rendering System
  Individual materials per block type with automatic fallback materials.
• Seed-Based World Generation
  Deterministic world generation using a configurable seed.
• Highly Configurable Inspector Settings
  Terrain scale, water level, rivers, lakes, trees, render distance, physics tuning.
• Single-Script Core System
  Easy integration and modification — no external dependencies.
• Runtime-Only (No Editor Tools Required)
  Works entirely at runtime, suitable for sandbox, survival, and voxel-based games.

Voxel Sandbox System is a complete, ready-to-use Unity asset that provides a full foundation for creating voxel-based sandbox games similar to Minecraft.

Core Features

• Procedural Infinite World Generation: Chunk-based system (default 16×128×16) using Perlin noise to create realistic terrain with hills, rivers, lakes, beaches (sand blocks), and randomly placed trees.
• Advanced Water Physics: True Minecraft-style finite water simulation – water sources, downward flow, horizontal spreading up to 7 blocks, falling water, proper level handling, and automatic updates when blocks are placed or removed.
• Player Controls: First-person movement including walking, sprinting, jumping, full swimming mechanics (directional movement based on camera, separate up/down speeds with Shift/Jump, buoyancy, drag), mouse look, and underwater visual effect.
• Building & Interaction: Accurate block highlighting with outline, left-click to destroy blocks, right-click to place blocks from the selected hotbar slot, configurable reach distance.
• Inventory System: 9-slot hotbar + 27-slot main inventory, stackable items (max 64 per stack), clean modern UI with item icons, counts, tooltips, hotbar selection via 1-9 keys or mouse wheel, inventory toggle with E key, right-click to transfer items between hotbar and inventory.
• Included Shader: "Cube6Textures" – a custom surface shader that allows different textures on each face of a cube (top, bottom, sides).

Customizability

Everything is highly customizable directly in the Unity Inspector:

• Terrain parameters (scales, heights, water level, tree density, seed, etc.).
• Movement and swimming speeds, gravity, jump force.
• Materials and icons for all block types.
• Easy extension of the BlockType enum and block database.
• All scripts are clean, well-commented, and modular, making it simple to add new features like mobs, crafting, or biomes.

Suitable Genre

Perfect for sandbox, survival, creative, or open-world building games in the voxel/Minecraft style. It delivers all core mechanics out of the box, saving months of development time and letting you focus on your unique gameplay ideas.

Drop the components into a scene, connect a few references, and you have a fully playable voxel world ready for further development.

Key Features:

• Procedural jigsaw puzzle generation at runtime
• Supports square textures (recommended resolution: 2048×2048)
• Automatic mesh generation with correct UV mapping
• Customizable rows and columns
• Adjustable piece shape (tabs, neck width, segments)
• Randomized piece placement and rotation
• Snapping system with distance control
• Automatic puzzle completion detection
• Inspector-based customization (no code required)
• Demo scene and offline PDF documentation included

Procedural Jigsaw Puzzle Generator is a customizable Unity system for creating jigsaw puzzle gameplay from any square image. The puzzle is generated entirely at runtime, automatically slicing the source texture into interlocking pieces with correct UV mapping.

Developers can control grid size, piece shape, snapping distance, randomization, and layout directly from the Inspector. The system supports puzzle completion detection and optional UI integration for menus or scene transitions.

This package is suitable for 2D games, casual and mobile puzzle projects, educational applications, and UI-based gameplay experiences.
It is designed to be easy to integrate, extend, and customize without modifying core logic.

Audio file types WAV

Sample rate 48000

Bit depth 16 bit

Loopable No

Additional Stereo

60 total sounds suited for horror projects, specialized for those involving snow.

• 11 Ambiences and Backgrounds
• 15 Electrical SFX
• 5 Knocks
• 10 Scary SFX
• 8 Snow Footsteps
• 11 Miscellaneous SFX

Inspired by the sound design of Fears to Fathom by Rayll

• Total Assets: 54 unique models.
• Compatibility: Fully supports Built-in, URP, and HDRP.
• Texture & Materials: Uses a single Texture Atlas (optimized for mobile performance).
• Polycount: Low Poly / High Performance (Avg. 200 - 800 triangles per model).
• Format: .FBX models.
• Setup: Prefabs included with colliders already set up for easy drag-and-drop.
• UV Mapping: Yes, optimized for color palette swapping.

Bring your game world to life with this Low Poly Nature Essentials Pack! Featuring 54 unique, hand-crafted models, this kit is perfect for creating vibrant forests, meadows, or stylized environments for mobile and PC games.

What’s inside?

• Trees: 26 varied models (Conifers, Round trees, Dead trees, and more).
• Rocks: 9 modular rocks for cliffs and terrain detailing.
• Stumps & Logs: 10 pieces to add history to your forest.
• Foliage: 4 Bushes, 2 Grass types, and 3 Mushroom varieties.

All models share a consistent, clean stylized aesthetic, making them easy to mix and match. Whether you are prototyping or building a final product, this pack provides the foundation you need.

• Digital delivery only
• 9 tracks
• Wav format
• All tracks are loopable

Dive into a world of immersive exploration with this expertly crafted collection of "dream-state" soundscapes. Designed to elevate both the journey and the story, these ethereal tracks blend calming rhythms with atmospheric textures, creating the ideal backdrop for fantasy realms and epic adventures. Whether your players are discovering uncharted lands or unraveling deep narratives, these melodies will transform their experience and set the perfect mood for every moment.

• Shimmer Effect shaders: for both HDRP and URP Project
• Shimmer Effect Materials: both HDRP and URP Shimmer Effect shaders applied materials
• Performance-friendly design: suitable for PC, console, tablet, and phones
• Friendly workflow: minimal setup, no coding required
• Demo scenes: included for fast onboarding
• Works with Unity 2021 and newer

Before purchasing, please review the 📖 Documentation

Thanks for checking out “Shimmer FX | Pickable Object Highlight | Shine FX”

This package gives you a flexible shimmer / highlight shader you can quickly drop onto items, UI, or any object you want to draw attention to.

The package contains one HDRP shader, one URP shader, and two pre-applied materials targeting PC, console, tablet, and phones.

The shader is good for highlighting collectables, bringing focus to a particular object, alerting danger, etc.

Compatibility

• Unity 2021.3 LTS or newer
• Universal Render Pipeline (URP) compatible
• High Definition Render Pipeline (HDRP) compatible