Asset Store newest packages

Supported Unity Versions:
2021.3 LTS or higher (tested on Unity 2022.3.x)

Platform Support:
✅ Android
✅ iOS
✅ WebGL
✅ PC/Mac (Standalone)

Dependencies:
❌ No external packages required
✅ Uses Unity UI (uGUI)
✅ PlayerPrefs for chip saving

Coding:

• 100% C#
• Modular structure
• Easy to extend and integrate
• Events exposed via public static Action<>
• Editor tools included (custom inspector)

UI System:

• Canvas-based (Unity UI)
• Prefabs for spin button, chips display, slot reels

Audio:

• Placeholder SFX included
• 🎧 Full audio used in demo not included (contact author if needed)

Mobile Ready:
✅ Optimized for touch input
✅ Lightweight and low-draw-call prefab setup

Slot Machine Kit – Plug & Play Reward System for Unity

Add a fully functional, customizable slot machine to your Unity project in minutes!

This lightweight, mobile-ready system is perfect for mini-games, daily rewards, lucky spins, or casino-style features. Designed for plug & play — no coding required, but powerful enough for full extension.

✅ Key Features:

• 🎮 Plug & Play: Just drag the prefab into your scene and hit play!
• 🎯 Reward Logic: ScriptableObject-based reward system with weighted chances
• 🔁 Auto-Spin Support: Tap-and-hold to auto-play mode
• 🎨 Customizable UI: Button states, slot icons, transitions all included
• 🧪 Debug Tools: Force results, add chips, and override reward for testing
• 🔊 Sound-Ready: Placeholder SFX included (demo audio not bundled)
• 🧩 Full Event System: Easily hook into spin, result, reward events
• 📱 Mobile Optimized: Built for performance and touch UX

🧪 Demo

• 🌐 WebGL: https://logcat.team/g/slotmachine/
• 📱 Android APK: https://drive.google.com/drive/folders/1vTVoV-4s3UXSWkyZG1PngQn_eOllap-p

📦 Includes

• Full C# source code
• UI prefabs (Canvas)
• ScriptableObjects for rewards
• Clean modular folder structure
• Built-in debug tools (_DEBUG flag)

📄 Online Documentation

https://logcat.team/docs/slotmachine.pdf

📩 Support

Email: hifromlogcat@gmail.com

Discord: logcatteam

Customization & publishing help available.

Bring your Unity URP scenes to life with this ready-to-use pack of 50 unique Volume Post-Processing profiles!

Whether you’re making a moody horror game, a neon sci-fi level, or a dreamy fantasy environment — this pack will save you time of tweaking settings manually.

**What’s inside:**

- 50 Volume profiles: Horror, Noir, Cyberpunk, Retro, Dreamy, and more

- Works with Unity’s built-in URP Volume (no extra plugins needed!)

- Demo scene to preview all presets in action

- Simple, clean folder structure

- Easy to use: drag & drop, adjust, done!

⚠️ Note:

This pack uses only Unity’s built-in URP Volume effects.

It does NOT include any custom fullscreen shaders, advanced glitch FX or scanline filters out of the box.

Some profiles (like glitch or scanline) are intended as style ideas — you can easily add your own fullscreen shader to complete these looks.

Everything works with the default URP Volume system — no extra plugins required.

**Requirements:**

- Unity URP (Universal Render Pipeline)

- Tested on [6000.2.0b2]

**Note:**

Some special looks (scanlines, glitch) may require a simple custom fullscreen shader for the best effect. Also you can easily correct what you don't like or what you want to add.

Perfect for solo devs, game jams, prototypes, or adding quick style to your scenes.

The IL2CPP PROTECT package offers a comprehensive set of security features designed to safeguard Unity projects using the IL2CPP scripting backend. Its key features include:

1. Encryption and Embedding of global-metadata.dat

Encrypts the critical global-metadata.dat file, which contains essential runtime metadata about your game's classes and methods. Seamlessly embeds the encrypted metadata into the build, making it difficult for attackers to access or analyze your game's internal structure.

2. Obfuscation of IL2CPP Classes

Transforms class names and structures to obscure and unintelligible forms. Enhances resistance against reverse engineering by complicating static and dynamic analysis of code.

3. Integrity Checks for IL2CPP Function Calls

Implements real-time verification of IL2CPP function calls. Detects and prevents tampering, injections, or unauthorized modifications to your game's core functions, maintaining code integrity.

Supported Platforms:

• Windows
• MacOS
• Linux
• Android

Note: iOS support is planned for future development.

Additional Information

Documentation: An overview of the settings in the configuration file can be found

here: https://github.com/CodesAndDaggers/IL2CPP_PROTECT/blob/bddba3d0c18f4fc9a8e7d821bde65ae08427b514/config.md.

Setup: No setup is required. Simply place the asset in the Assets folder and build your project.

**IL2CPP PROTECT – Protect Your Assets and Data**

Are you looking to safeguard your Unity projects from unauthorized access, reverse engineering, and intellectual property theft? IL2CPP PROTECT is your comprehensive solution for protecting your Unity application's core data and code. Designed with developers' needs in mind, this powerful asset offers multiple layers of security to ensure your project remains secure and uncompromised.

### Key Features:

**1. Encrypts and Embeds the global-metadata.dat File**

The `global-metadata.dat` file is a critical component of Unity's IL2CPP scripting backend, containing essential metadata about your game's classes, methods, and other runtime information. Protecting this file from tampering or extraction is vital, as it can reveal your game's structure and logic. Our tool encrypts and seamlessly embeds this file into your build, making it significantly more difficult for attackers to access or analyze your game's internals. This layer of security helps prevent reverse engineering and unauthorized modifications, safeguarding your intellectual property.

**2. Obfuscates IL2CPP Classes**

Understanding IL2CPP classes is a common goal for malicious actors attempting to reverse engineer your game. Our obfuscation feature transforms class names and structures, making them obscure and unintelligible. This process complicates static and dynamic analysis, deterring attempts to understand or modify your code. By obfuscating IL2CPP classes, you enhance your project's resilience against hacking tools, intellectual property theft, and cheating mechanisms.

**3. Checks Integrity of IL2CPP Function Calls**

Tampering with function calls can compromise your game's security, leading to cheating, exploits, or unauthorized content access. Our asset implements integrity checks for all IL2CPP function calls, ensuring that any unauthorized modifications or injections are detected promptly. This real-time verification helps maintain the integrity of your game's logic, providing peace of mind that your application's core functions are protected against tampering.

---

### Why Is Project Security Important?

In today's digital landscape, protecting your Unity project isn't just about safeguarding your code—it's about preserving your creative work, revenue, and reputation. Unauthorized access can lead to piracy, cheating, data theft, and loss of competitive advantage. By implementing robust security measures early in your development process, you reduce the risk of malicious attacks and ensure a safer environment for your users.

Furthermore, protecting sensitive files like `global-metadata.dat` and obfuscating classes make it more challenging for hackers to dissect your game, minimizing the chances of exploits and leaks. This not only preserves your intellectual property but also enhances your project's credibility and trustworthiness.

---

### Supported Operating Systems

Our Unity Project Security Tool is versatile and designed to support a wide range of platforms, including:

- **Windows**

- **macOS**

- **Linux**

- **Android**

*Note:* Support for **iOS** is currently under development and untested. We are actively working to provide full compatibility for iOS devices in future updates.

---

**Secure your Unity projects today with our all-in-one security solution. Protect your hard work from threats and ensure your game's integrity across multiple platforms!**

CodesAndDaggers@null.net

URP Sharpening Post-Process Effect

# Enhanced image clarity for superior visual quality in both 3D scenes and UI elements.

URP-Compatible

# Designed for Universal Render Pipeline

Volume System Integration

# Configurable via URP Volume Override (ScriptableRendererFeature)

Multi-Camera Sharpening Modes

# Full-Screen Mode: Sharpens both Game + UI (UI Camera)

# Scene-Only Mode: Targets 3D content only (Main Camera)

Performance-Optimized

# Single-pass shader with adjustable intensity

Includes Demo Assets

# View the complete screenshot demo

License & Attribution

# This package includes third-party assets licensed under CC BY.

# Full attribution details in ThirdPartyLicenses.txt.

Unity versions:

- 2020.3 LTS and newer

- Properly tested on 2023.2.20f1;2022.3.62f1;2021.3.45f1;2020.3.48f1

- Requires C# 8.0+

- Made with 6.0.45f1

Rendering pipelines: Built-in, URP, HDRP

Dependencies: None

Runtime allocations:

- Minimal GC allocations during capture and restore

- Core snapshot operations use object and memory pools to avoid spikes

Threading:

- Main-thread safe; heavy I/O handled via async Tasks and coroutines

Support

- Email and Discord (details in the README file inside the package)

Dual-Mode API

  - SnapshotService - classic slot-based save / load with async calls

  - VersionedSnapshotService - full timeline control using keyframes and delta snapshots  

Rewind & Replay

- Run scene-wide or per-object rewind and generate frame-perfect replays from per-frame deltas  

Branching Timelines

- Fork separate “what-if” branches at runtime and jump between them instantly  

Adapter System

- 30+ built-in adapters like Transform, Rigidbody, Animator, Colliders etc

- Add any custom component in ~20 lines via clean "IChronoAdapter" interface

GC-Efficient Performance

  - Object and list pools for snapshots and entries keep allocations low

  - Typical snapshot and restore operations run in single-digit milliseconds on mid-range hardware  

  - Coroutine-driven pipeline prevents frame-time spikes during long captures  

Dependency-Aware Restoration

- Automatic topological ordering (Transform → Rigidbody → custom) removes load-order bugs

Stable GUID Tracking

- ChronoTarget IDs persist through instantiation, destruction and scene loads; no broken references

Modular Storage

- in-memory `MemoryStore` and encrypted `FileStore` included; extendable via `ISnapshotStore` for cloud, database or PlayerPrefs back-ends  

Editor Tooling 

- dedicated inspectors for Auto-Detection objects;Snapshot editor window;Diagnostic Window

Full C# code

- clean, well documented with interface separation and unit-test-friendly design

Number of Animations: 56

Animation types: Root Motion: 40 In-place: 16

Number of Characters: 1

Windows: Yes

The package consists of walking, running, attacking, crawling and idle animations.

• Over 30 API methods for advanced camera and coordinate control
• Smart Demo System with automatic Unity environment detection
• Unified Raycasting System (3D and UI combined)
• Safe Area Support for mobile (notches, cutouts, rounded corners)
• Event-driven architecture with full event system
• Works out of the box – no manual setup required
• Clean architecture following SOLID principles
• Fully tested (26 automated tests passed)
• No runtime memory allocation
• Complete documentation with PDF guide and code examples
• Cross-platform support for Mobile, Desktop, Console, and WebGL
• Compatible with all render pipelines (Built-in, URP, HDRP)
• Supports both Legacy and Unity Input System packages
• Resolution-independent with automatic screen adaptation
• Automatic camera detection with intelligent handling
• Coordinate conversion between Screen, World, Viewport, and UI spaces

🎯 EG.Vision System – Universal Camera & Coordinate Management

Stop writing boilerplate code! EG.Vision System delivers a complete, production-ready solution for camera control and coordinate conversion in Unity. Reduce your code by up to 90% while gaining advanced functionality.

✨ SMART DEMO SYSTEM

• Automatically detects your Unity environment (version, render pipeline, input system)
• Generates optimized demo scenes tailored to your setup
• Includes 4 comprehensive, real-world scenarios
• Works out of the box with most project configurations

🚀 CORE FEATURES

• Universal Camera Management – Handles detection, switching, and multi-camera setups
• Advanced Raycasting – Unified 3D + UI raycasting with extended hit data
• Coordinate Conversion – Accurate Screen ↔ World ↔ Viewport ↔ UI transformations
• Safe Area Support – Full API for managing notches and screen cutouts on mobile
• Event System – Real-time events for resolution, orientation, and layout changes

💎 PRODUCTION-READY

• Fully tested (26/26 unit tests passed)
• Clean, modular, and SOLID-compliant architecture
• Zero runtime memory allocations
• No configuration required
• Comes with complete documentation and a detailed PDF guide

🔧 BROAD COMPATIBILITY

• Unity 2022.3 LTS and newer
• All Render Pipelines: Built-in, URP, HDRP
• Supports both Legacy and Input System packages
• Cross-platform: Mobile, Desktop, Console, WebGL

⚡ PERFORMANCE OPTIMIZED

• Designed for high-FPS applications (60+ FPS)
• Efficient, mobile-friendly algorithms
• Minimal memory footprint
• Optimized update cycles

🎮 IDEAL FOR

• Mobile games with dynamic UI adaptation
• Multi-camera applications and transitions
• AR/VR projects requiring precision coordinate handling
• Any Unity project needing advanced camera logic

EG.Vision System is a third-party tool and is not affiliated with or endorsed by Unity Technologies.

Editor Notes - Technical Features

Core Functionality

• GameObject Association - Notes linked to unique object identifiers
• Persistent File Storage - Notes saved to project files via EditorNotesFileHandler
• Serializable Data Structure - Clean, lightweight Note class implementation
• Editor-Only Operation - Zero runtime performance impact

Key Features

Data Management

• Unique Object Binding - Each note tied to specific GameObject via TargetObjectUniqueId
• Automatic Serialization - System.Serializable Note class for Unity compatibility
• File-Based Persistence - Notes stored in project directory structure
• Content Validation - Robust handling of note content and object references

Editor Integration

• Custom Inspector Support - Ready for editor GUI implementation
• Scene View Compatible - Can be extended for in-scene note display
• Asset Database Integration - Properly integrated with Unity's asset management
• Version Control Friendly - Note files work seamlessly with Git/Perforce

Architecture

• Modular Design - Separate file handling and data management layers
• Extensible Framework - Easy to add features like categories, tags, or search
• Memory Efficient - Lightweight objects with minimal memory footprint
• Thread Safe Operations - Safe file I/O operations for editor use

Technical Specifications

• Unity Version - Compatible with Unity 2019.4 LTS and newer
• Platform Support - All Unity-supported platforms (editor-only)
• File Format - Custom serialized format via EditorNotesFileHandler
• API Surface - Simple, clean public interface for easy integration

Developer Benefits

• No Runtime Dependencies - Pure editor tool with no game impact
• Minimal Setup - Drop-in solution requiring no configuration
• Clean Codebase - Well-structured, maintainable C# implementation
• Extensible Design - Easy to customize and extend functionality

Editor Notes - Unity Asset Store Package

What It Is

A lightweight Unity editor tool that lets you attach text notes directly to any object in your project. Think of it as digital sticky notes for your GameObjects - write reminders, document functionality, or leave notes for your team members.

Key Features

• Attach notes to any GameObject in your scene or project
• Persistent storage - notes save automatically and stay with your project
• Clean, simple interface - no complicated setup required
• Team-friendly - share project knowledge easily with collaborators

How It Helps Your Project

For Solo Developers

• Never forget your ideas - document complex logic as you build
• Track bugs and fixes - note issues you need to address later
• Remember design decisions - explain why you set things up a certain way
• Speed up development - quickly recall what each object does

For Teams

• Knowledge sharing - explain your work to other developers
• Onboarding - help new team members understand the project
• Code documentation - add context that comments can't provide
• Version control friendly - notes travel with your project files

Common Use Cases

• "This enemy AI needs balancing - too aggressive on level 3"
• "Door animation controller - linked to pressure plate script"
• "Performance note: This spawner can lag with 50+ objects"
• "Bug: Sound sometimes doesn't trigger - check audio source"
• "Remember to adjust lighting when scene is finalized"

Why Choose Editor Notes?

✅ Saves time - No more digging through code to remember what things do
✅ Improves organization - Keep your project well-documented
✅ Reduces errors - Remember important details and edge cases
✅ Enhances collaboration - Clear communication within your team
✅ Zero performance impact - Editor-only tool, doesn't affect your game

• Fully customizable thirst, hunger, health, and stamina values.
• Includes easy-to-implement scripts for integration into your project.
• Simple UI elements to display vitals (can be customized).
• Dynamic changes based on in-game events (e.g., actions that affect health or stamina)
• Eating drinking damage and death sounds
• Supports Built-In,HDRP and URP
• PDF explaining how to set up scene.
• Damage and death events system (ex: Fire,knife)
• Clean Inspector control
• Custom decay rates etc

This asset provides an advanced system for tracking and managing player vitals, including thirst, hunger, health,stamina and damage system. It is highly customizable. The system is designed to be flexible, so developers can adjust values, behaviors, and UI elements to suit their specific needs. It has damage and death events system, infinite amount of possibilities.

Multiple PDF's explaning how to set the scene up, common errors.

Eating drinking damage and death sounds

• Works in editor (not a runtime tool)
• Quick prefab placement
• Placement layer mask control
• Custom parent asset support
• Indicator for placement visualization
• Orient to surface fuctionaility
• Scale and Rotation variation
• Multi-prefab support
• Undo functionailty
• Tool preferences saved between sessions
• Scriptable objects for custom tool setting profiles

This tool allowa you to quickly place prefab assests by just clicking where you want an asset to go, similar to how details are placed on terrains. It was created with non-unity users in mind such as designers and artists but useful to anyone that hates dragging hundreds of objects manually into a scene one at a time.

The tool has controls for selecting randomly from a list of prefab assets as well as for varying the scaling and Y axis rotation of the placed object. Great for placing vegetation and environment assets. Supports a custom parent object for placed assets to keep your scene tidy and the creation of settings objects to save and switch between brushes.

Undo functionailty for placed assets and scripting values saved between sessions for minimal disruption to work flow. Designed to be an out-of-the box tool. Just put your prefabs in and go!

**DEMO ASSETS SHOWN IN VIDEO NOT INCLUDED IN PACKAGE. THIS IS ONLY THE EDITOR TOOL

Asset uses Expresso Dolce and Della Respira Fonts under SIL OPEN FONT LICENSE; see Third-Party Notices.txt file in package for details."

Features:

- Configurable transition sizes and quality

- Automatically works for everything

- Easily Disable/Enable the effect for certain objects using a layermask

- Works with textured materials

- As post process automatically updates real time without regenerating anything.

Limitations:

- Only works for opaque objects

- Imperfections become visible from close up (Configurable fading distance)

This URP post processing effect adds transitions in between seams of meshes,

This masively reduces hard seams when combining meshes together, which allows for rapid iteration of building terrains or environments without having to make custom assets for everything.

UI Framework:

• Built with Unity uiElements (Unity UI Toolkit) for a modern, responsive Editor interface.

Key Features:

• PixelArt Scaler: Convert blurry AI-generated art into clean pixel-perfect assets using smart scaling algorithms.
• Background Remover: Quickly remove solid backgrounds with customizable color key and edge softness.
• Image Part Detector & Separator: Automatically slice spritesheets or tilesets into individual images with threshold, padding, and size filtering options.
• Color Correction Tool: Adjust brightness, contrast, hue, gamma, exposure, and more -plus grayscale, invert, and temperature/tint effects.
• Non-Destructive Editing: Load, revert, and save changes to retain flexibility during asset creation.
• Editor-Only: No external software or cloud tools required - runs entirely inside the Unity Editor.

Performance:

• Lightweight and fast. Optimized for 2D asset pipelines and works well on low-spec development machines.

Compatibility:

• Compatible with URP, HDRP, and Built-in Render Pipeline (image tools are render-agnostic)

Note:

This package is a focused subset of uAI - Pro Creator. If you own that asset, Image Tools is already included.

Image Tools - Essential Image Editing Inside Unity

Image Tools is a compact yet powerful set of in-Editor utilities designed to simplify and enhance your 2D asset workflow in Unity. Whether you're cleaning up sprites, scaling pixel art, or separating tilesets, these tools save time and keep you focused on building your game - not switching between external programs.

Extracted from the full uAI - Pro Creator suite, these tools are perfect for any developer working with AI-generated art, retro-style assets, or detailed sprite sheets.

🛠️ Included Tools:

🧩 Image Part Detector and Slicer

Split tilesets, sprite sheets, and composite images into clean, individual parts.

• Auto-detect objects and transparent backgrounds.
• Customize threshold, padding, and minimum part size.
• Export each part as a separate image with a click.

🎯 PixelArt Scaler

Fix blurry pixel art and restore that crisp, retro look.

• Auto-detect or manually set pixel grid size.
• Clean scaling using smart algorithms like Nearest Neighbor and K-Centroid.
• Ideal for turning fuzzy AI outputs into game-ready pixel art.

🚫 BackGround Remover

Remove flat-colored backgrounds in seconds.

• Color key remover with adjustable tolerance and edge softness.
• Includes manual eraser tool for fine-tuned edits.

🎨 Image Color Correction

Professional-grade adjustments, right inside Unity.

• Tweak brightness, contrast, saturation, gamma, exposure, and more.
• Advanced tonal controls: black point, white point, midtones.
• One-click effects: grayscale, invert, temperature & tint.
• Safe, non-destructive workflow with load/save/revert options.

Read our documentation for further instructions. Please scroll to the corresponding tools, since this is the full documentation for uAI Pro Creator.

💡 Want More?

This package is part of uAI - Pro Creator.

If you purchase uAI Pro Creator, these image editing tools are already included, along with a full suite of AI-powered tools for scripting, 3D model generation, shader creation, sound design, and much more.

Key Benefits:

• All tools work natively inside the Unity Editor (no external software).
• Built with Unity UI Toolkit for modern performance and UI.
• Lightweight, fast, and easy to use.

Upgrade your Unity workflow with Image Tools - and bring your visuals to life with clarity and precision.

📘 What to Expect? 📘

The [Scene] Attribute allows you to reference scenes and add them to the build index all within the Inspector for a cleaner look and to help increase your producitivity and code quality.

[Scene] can be placed on any string type variable including lists, arrays, and more. This attribute will serialize any SceneAsset as a path to allow you to dynamically refer to a scene when working with the SceneManager and is self correcting if the SceneAsset is later moved.

🧧 Features 🧧

- Easeful Integration

- Extremely Lightweight

- Built-In PropertyDrawer

Easeful Integration:

As the [Scene] attribute is completely self contained, the PropertyAttribute and PropertyDrawer are contained within a single script making it easy to organise and slot into any project.

Extremely Lightweight:

[Scene] is extremely lightweight as it's an Editor-only Attribute for the Inspector. There will be no difference in performance for runtime or for your builds as it serializes as a string.

Apply [Scene] to any type of string!

Built-In PropertyDrawer:

The PropertyDrawer makes the bulk of the [Scene] Attribute by providing you with the tools necassary to improve your workflow and easily aid designers. The PropertyDrawer contains an object field that displays all SceneAssets within the Project and includes the ability to drag and drop. 

Additionally it displays whether or not this scene is apart of the Build Index so you know whether or not your scenes will be up and running upon Building your Project. Click the button to add or remove the Scene from the Build Index.

✨ What's Next? ✨

- A more customisable SceneReference class will be added in the near future to give more control over referencing scenes. (For better serialisation).

📙 Support 📙

For support, feedback, or bug reports, you can contact me at:

• me@aiden.fyi

Low Poly Mesh game-ready.

Real-World Scale (Centimeters).

Tris Count: 1112

Number of Textures: 1

Number of Textures: 1

Handpainted Texture (2048x2048) (PNG).

Type of Texture: Base Color

UV mapping: Yes

URP Render Pipeline

Stylized Pilsner Cup Handpainted.

More Products: https://assetstore.unity.com/publishers/80907

Low Poly Mesh game-ready.

Real-World Scale (Centimeters).
Tris Count: 1112

Number of Textures: 1

Number of Textures: 1
Handpainted Texture (2048x2048) (PNG).
Type of Texture: Base Color

UV mapping: Yes

Stylized Pilsner Cup Handpainted.

More Products: https://assetstore.unity.com/publishers/80907

4 sets of Textures.com files of 2048 px.

Albedo, Normal, and Occlusion.

Scene, terrain, and ocean plane.

Terrain ready to be used and edited as you please.

Water and skybox in preview not included.

Key features:

• Visual Data Management: View and edit ScriptableObject data in a familiar spreadsheet format
• Formula Support: Use Excel-like functions and formulas for data calculations
• Data Import/Export: Import data from CSV/JSON files and export tables to various formats
• Intelligent Copy/Paste: Copy and paste values between TableForge and other programs like Excel easily
• Advanced Filtering: Filter and search through table data efficiently

Minimmum Unity Version: Unity 2022.3

TableForge is a powerful Unity Editor tool designed for managing, visualizing, and manipulating tabular data from ScriptableObjects. It provides a spreadsheet-like interface with advanced features for data analysis, formula support, and data import/export capabilities.

For more information refer to the TableForge GitHub page.

Number of textures: 134

Texture dimensions: 4096x4096, 2048x2048, 1024x1024

Polygon count: 227,090

Number of meshes: 240

Number of prefabs: 720

Rigging: Yes

Animation count: 0

Animation type list: 0

UV mapping: Yes

LOD information: 0

Types of materials and texture maps: PBR

Highly detailed, realistic 3D Fantasy Characters with modular parts. There's a male and female version.

Characters are made up of modular parts, human body parts can be excluded to avoid overlap and reduce polycount.

Character does not have LOD system

Key Features

• Supports Built-in, URP, and HDRP
• Fully Rigged with Humanoid Rig
• Advanced materials with easily customizable colors
• Includes full-body mesh and modular parts

Materials

Materials are made in Shader Graph. There are three types of materials, one for each rendering pipeline (URP, HDRP, StandardRP).

Each outfit part supports three independently customizable color regions, controlled via a Material ID map. Patterns can be added and adjusted for each color region.

There are also a customizable hair material, a procedural eye material, and a skin material with adjustable skin tone and separate, toggleable makeup layers (e.g., lips, eyes, blush), each with individual controls.

Outfit and skin materials include configurable layers for dirt and blood effects.

All materials are easily extendable, allowing the addition or removal of layers if needed.

4K Textures

BaseColor, Normal, IDMap, ORM(OcclusionRoughnessMetallic), SSS (Subsurface Scattering), Specular, Cavity, Parallax, Opacity

Polycount

Male (most complex variation)

Faces 55,005 ・ Tris 107,468 ・ Verts 61,063

Female (most complex variation)

Faces 61,057 ・ Tris 119,622 ・ Verts 69,024

PLEASE NOTE THAT THERE ARE NO BLUEPRINTS!

PolyCount RockerGirl Emma : Verts: 71095 , Faces: 67256 , Tris: 90646

Facial expressions are included (Morph Targets, Blendshapes).

Tested with Live link Face ( See Video )

You can use this model for face mocap (live stream) and conversation animations.

PBR Textures Metall/Roughness

Roughness map inside Albedo

4K Textures

The model is completely modular.

The full body under the clothes is included, it's not a cutout!

Body Censored if you need i can send you uncensored version.

Rigged with Humanoid Skeleton.

Additional bones: https://docs.google.com/document/d/1FhpCCtAt4WQdNpppsLs4n_Do2McVIy7722r0y45Upcw/edit?usp=sharing

• Used Source File Sizes: 16x16
• File Count: 196
• Animated: Yes
• Animation Type List: Idle, Walk, Jump, Climb
• Additional: Pixel-based

This package is good for anyone looking to build a 2D pixel platformer. It offers animated charector sprites as well as tile sets to start work on your 2D project. Package contains 2D PNG files.