Asset Store newest packages

Engine Compatibility

• Unity 2021.3 LTS or newer (recommended 2022+)

Render Pipelines

• Built-in Render Pipeline ✅
• Universal Render Pipeline (URP) ✅
• (No special pipeline setup required)

Platform Support

• Windows, macOS, Linux
• Mobile (iOS, Android)
• WebGL

Target

• 2D projects (SpriteRenderer-based)

Core Components

• PixelPopOnDestroy (MonoBehaviour)
• PixelPopSystem (runtime handler)
• PixelChunk (lightweight animated chunk)
• PixelPopPreset (ScriptableObject)

Key Features

• Grid-based sprite breakup (configurable density)
• Scripted motion (no Rigidbody2D required)
• Built-in presets (Arcade Pop, Explosion Burst, Soft Break)
• Fade-out and optional scale shrink
• Works with any SpriteRenderer
• Simple API for manual triggering
• Optional object pooling (included in final version)

Performance

• Lightweight and allocation-conscious
• Designed for multiple simultaneous effects
• No physics simulation overhead
• Suitable for mobile and low-end devices

Dependencies

• No external packages required
• No third-party libraries
• Works out of the box with Unity

Code Quality

• Clean, modular architecture
• Easily extendable (presets, pooling, editor tools)
• Well-organized namespaces and scripts

Included Content

• Runtime scripts
• Presets
• Demo scenes (enemy death, breakable objects, stress test)
• Documentation (quick start + examples)

Limitations (honest but safe)

• Designed for 2D SpriteRenderer objects only
• Uses stylized grid-based breakup (not realistic fracture simulation)

Stop letting your enemies and objects disappear without impact.

PixelPop FX makes every destruction moment feel satisfying, punchy, and fun — in seconds.

Add a single component to any sprite, and when it’s destroyed, it bursts into animated pieces that fly outward, rotate, and fade away beautifully. No setup headaches. No complicated systems. Just instant results.

Whether you’re building a platformer, action game, or casual mobile experience, PixelPop adds that missing layer of polish that makes your game feel like a real product.

💥 Why PixelPop FX?

Because small moments matter.

A good destruction effect:

• makes combat feel impactful
• makes rewards feel satisfying
• makes your game look polished instantly

PixelPop focuses on doing one thing really well — and making it effortless.

🚀 Features

• 🧩 Works on any 2D sprite
  Drop it in and go — no special setup required.
• ⚡ Instant “pop” effect on destroy
  Objects break into animated chunks automatically.
• 🎯 Satisfying motion out of the box
  Chunks burst outward, rotate, and fade with smooth timing.
• 🎨 Multiple presets included
  From snappy arcade pops to softer break effects.
• 🖱️ One-component workflow
  Add, press play, destroy — done.
• 🧠 Lightweight & clean
  No heavy systems, no dependencies, no clutter.
• 🔄 Performance-friendly
  Designed to handle multiple effects smoothly.

🕹️ Use Cases

• 💀 Enemy death effects
• 📦 Breakable crates and props
• 💰 Reward and pickup bursts
• 🎯 Hit reactions in 2D games
• 🧪 Game jam polish in minutes
• 📱 Casual and mobile games

Render Pipeline: Universal Render Pipeline (URP)
Unity Version: 2021 LTS or newer (recommended 2022 LTS+)
Shader Type: Screen refraction using camera color sampling
Technique: Mesh-based local distortion
Opaque Texture: Must be enabled in URP settings

Included Components:

• HeatDistortionZone (C# runtime controller)
• HeatDistortion shader
• 6 preset materials
• Demo scene with example setups

Adjustable Parameters:

• Distortion Strength
• Noise Scale
• Animation Speed
• Vertical Fade Height
• Intensity Multiplier

Compatibility:

• 3D projects (recommended)
• 2D projects (via quad or mesh sprite)
• Desktop and console platforms
• Mobile compatible (depending on device capability)

No external dependencies.

Procedural Heat Distortion (URP) is a lightweight, production-ready heat haze and refraction shader for Unity’s Universal Render Pipeline.

Easily add realistic heat shimmer above fire, lava, engines, or desert ground using simple mesh-based distortion zones. No complex setup. No custom render passes. Just assign the material and adjust a few parameters.

Perfect for:
• Fire heat haze
• Desert mirage effects
• Lava shimmer
• Engine exhaust distortion
• Environmental refraction
• Cinematic heat waves

The effect works by procedurally distorting the camera color behind a mesh using animated noise. This allows for localized, physically convincing heat shimmer without full-screen post-processing.

Included Preset Materials

The package includes 6 ready-to-use materials:

• Strong – High intensity heat distortion
• Subtle – Light ambient shimmer
• Desert Mirage – Wide, soft ground mirage effect
• Turbulent – Chaotic, aggressive distortion
• Lava Heat – Heavy, rising thermal shimmer
• Exhaust – Focused, directional engine distortion

Simply drag a preset onto a quad or mesh and you’re done.

Key Features

• Local mesh-based heat distortion (not full screen)
• Procedural animated noise (no flipbooks required)
• Vertical fade for realistic rising heat effect
• Adjustable strength, scale, and speed
• Works in both 3D and 2D (via quad or sprite mesh)
• Optimized for URP
• No runtime allocations
• Clean, minimal C# controller

Why This Asset?

Many heat distortion solutions rely on complex renderer features or global post-processing. This asset keeps things simple and modular:

✔ Drop-in ready
✔ Lightweight
✔ Easy to customize
✔ Production-friendly

Ideal for indie developers and small teams who want professional heat shimmer effects without heavy pipeline configuration.

• 16 unique models, ranging from 357 to 645 triangles
• 128 carefully set up and organized prefabs, for each rendering pipeline (384 total)
• 4 albedo maps, one for each roof color (4096 x 4096 pixels)
• 4 albedo maps, one for each roof color, covered by snow (4096 x 4096 pixels)
• 2 height maps (4096 x 4096 pixels)
• 2 normal maps (4096 x 4096 pixels)
• 2 hue masks (4096 x 4096 pixels)
• 2 metallic / smoothness maps (4096 x 4096 pixels)
• 2 ambient occlusion maps (4096 x 4096 pixels)
• 2 HDRP Mask maps (4096 x 4096 pixels)

This package contains a set of medieval houses with multiple color variations each and both a default / snow-covered variant.

HIGHLY OPTIMIZED

Each variation-set shares a single material and is textured as an atlas for reduced draw-calls, making it perfect for top-down & strategy games, even in mobile platforms.

DESIGNED FOR

- Top-down and ARPG adventure games

- Strategy or city-builder games

- Casual games for mobile

- Prototypes and Game Jams

WHAT MAKES IT UNIQUE

Each model was carefully handcrafted, modeled in Blender and painted in Substance Painter. No AI was used in any part of the process.

Multiple color variations and winter sets (covered by snow) are provided so that you can make your scenes unique, adding more variation than standard model packs usually allow.

An additional Hue mask is provided so that tech-savvy users can further modify the color of the roofs with ease for endless variations through their own custom shaders.

QUESTIONS OR SUGGESTIONS?

All of our assets have been praised for the user support we provide, so if you have any doubts about our products before or after your purchase, please do not hesitate and contact us at support@irreverent-software.com

Key Features

• Quantum circuit simulation framework built in Unity (C#)
• Support for core quantum gates: Hadamard (H), Pauli-X (NOT), Phase (S), and CNOT
• Single-qubit visualization using Bloch Sphere representation
• Multi-qubit system support with state vector simulation
• Entanglement support (Bell states and GHZ states)
• Real-time probability amplitude and measurement visualization
• Modular and extensible architecture for adding custom gates
• Integration with CSharpNumerics for numerical computations
• Designed for real-time interaction and visualization in Unity scenes
• Lightweight and easy to integrate into existing Unity projects

Quantum Circuit Simulator is a Unity-based toolkit for visualizing and simulating quantum computing concepts in real time. It provides support for fundamental quantum gates, Bloch sphere visualization, and multi-qubit systems including entanglement (Bell and GHZ states).

Designed for developers, educators, and researchers, it makes it easy to integrate interactive quantum simulations into games, educational tools, or scientific applications using C# and CSharpNumerics.

-Number of models: 12

- Image textures: 1

- Maximum polygon count: 7,000

- Minimum polygon count: 500

- Average polygon count: 1200

- Number of meshes: 12

- Models are rigged

- This package CONTAIS MULTIPLE ANIMATIONS

- UV mapping

- You can ask for different LOD at littlesimplecz@gmail.com

Package content

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

Welcome to the ultimate foundation for your next Low Poly Fantasy RPG!

This comprehensive package provides everything you need to jumpstart your action RPG, adventure game, or fantasy prototype. Featuring unique, fully rigged characters, a robust plug-and-play third-person controller, and a rich library of combat animations, you can go from an empty scene to a fully playable character in minutes.

🌟 CORE FEATURES

• 4 Unique Fantasy Characters: Carefully crafted low-poly models including a Hooded Mage, a Skull-Masked Warrior, a Forest/Nature Fighter, and a Red-Armored Rogue.

• Advanced Third-Person Controller: A highly polished, game-ready locomotion system. Includes smooth walking, running, and a full crouch movement system, all perfectly set up using advanced 2D Blend Trees for seamless transitions.

• Extensive Animation Library: A massive collection of custom animations ready for any gameplay scenario. Includes: Spell Casting (Ground & Two-Handed), Great Sword Slashes, Sword & Shield Attacks, Dodge Rolls, Kicks, Taunts, Hit Reactions, and multiple Death animations.

• Epic Cloth Physics: Garments, robes, and capes come to life! Experience highly polished, dynamic cloth simulations that react beautifully to every movement, sprint, and combat action.

• Custom Weapons & Interactive Magic: Equip your heroes with stylish game-ready weapons. Includes a standout Interactive Magic Staff featuring a custom levitation/rotation script for the glowing orb and a built-in Particle System (VFX) for a truly magical feel!

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

📦 COMPLETE PACKAGE CONTENT

🧍 Characters (Fully Rigged Prefabs):

• Blue Mage
• Green Mage
• Necromancer
• Red Assassin

⚔️ Weapons & Props:

• Dagger (2 Variations)
• Longbow & Arrow
• Longsword & Standard Sword
• Shield
• Magic Staff (Includes the interactive animated 'Staff Core' orb)
• Necromancer Staff

🏃‍♂️ Locomotion Animations (Blend Tree Ready):

• Idle & Jump
• Walk (Forward, Backward, Left Strafe, Right Strafe)
• Run (Forward, Backward, Left, Right)
• Crouch System (Crouch Idle, Crouch Walk Forward, Backward, Left, Right)

🔥 Combat & Action Animations:

• Magic: Casting Spell, Ground Casting, Two-Hand Spell Casting
• Melee Attacks: Great Sword Slash, Sword & Shield Attack, Sword & Shield Slash 1 & 2
• Defense & Agility: Roll, Kick
• Reactions: Getting Hit (3 Unique Variations), Taunt
• Defeat: Standard Death, Standing Death Backward

Other low poly packs

Low Poly Dinosaur T-rex Pack

MarineLife Mega Pack

LowPoly Tropical Fish & Coral Pack

Custom models here

My fiverr contact

Mining Dump Truck Lowpoly with interior 3D model was created on real dumper base.

Underground articulated truck with 20-tonne load capacity 

It’s created accurately and maximally close to the original.

easy change color textures:

Features:

• - all prefabs object are separate 
• - Body-polys:15944,tris: 30613,verts:16733
• - 4K Textures 
• - Model is correctly divided into main part and wheels. 
• - Steering Separated
• - Door are Separated
• - Included basic interior. 
• - Completely unwrapped and textured.
• - Professional, clear geometry.
• - Optimized for games.
• - All materials, textures and other parts of pack properly named.

We greatly appreciate you choosing our 3D models and hope they will be of use. We look forward to continuously dealing with you.

if you find any correction and additional technical details feel free to contact me..

<a href="mailto:address">lowpolymaster@gmail.com</a>

Number of textures: 6(Roughness, Normal, Diffuse),

Texture dimensions: 2048 x 2048, 512 x512

Polygon count of "Stacked Plates": 2620

Minimum polygon count:

Maximum polygon count: 2620

Number of meshes-prefabs: 42 - 42

Rigging: No

Animation count: 0

Animation type list: None

UV mapping: Yes

LOD information: None

Types of materials and texture maps :PBR

This is a modular pack which means that it could be rearranged in different forms in order to match your project in mind. Objects in this asset has their origin point stated at correct positon which helps in animating the objects. The textures as well could be changed to your liking. All these are stylized mateirals to they would not appear to be real. We sincerly hope that you find what you are looking for in this asset. Thank you for purchasing. Enjoy!

Engine Compatibility: 

• Unity (URP & HDRP supported)
• Rendering: PBR (Physically Based Rendering) 
• Polygon Count: ~4,000 triangles 
• Textures: 4K resolution (PBR workflow) Albedo/Base Color, Normal Map, Metallic Roughness (or Smoothness for Unity)
• Texture Format: PNG/TGA (engine-ready) 
• UV Mapping: Optimized and non-overlapping UVs

This weapon is a stylized, retro-inspired handgun based on the iconic C96 Mauser design. It blends historical aesthetics with a modern tactical interpretation, featuring a modular structure and a compact stock attachment for enhanced usability. The model is designed with a semi-realistic approach, making it suitable for both realistic and stylized game environments, including FPS, third-person shooters, and indie projects. The asset is optimized for real-time applications and built to be easily integrated into modern game engines, providing flexibility for customization and performance.

• Unity Version: 6000.53+
• Render Pipelines: All supported (URP, HDRP, Built-in)
• Platforms: All Unity-supported platforms
• Documentation: English & Chinese

🎯 Zero-Code + Production-Grade Visuals All configurations completed in the Inspector—no coding required to achieve professional-grade visual effects. Drop in a ChartProfile, and professional charts render instantly.

⚡ Minimal Workflow, Maximum Efficiency Configure → Clone → Change Data → Done

One ChartProfile drives both UI Toolkit and UGUI, eliminating duplicate configuration efforts. Edit once, sync across the entire project. Designers and developers work in parallel without blocking each other.

🏗️ Core Architecture

Single Source of Truth One ChartProfile asset powers both UI Toolkit and UGUI.
Edit once, render anywhere—eliminate platform-specific repetitive work.

Library — Enterprise-Level Design System Hub

• Visual Library Editor: Centralized management of all chart Profiles, supporting create, edit, delete, rename, and categorize.
• Live Preview: Select a Profile for instant rendering preview—no need to enter Play Mode, what you see is what you get.
• Cross-Project Reuse: The Library exists as a standalone asset, allowing multiple projects to share a unified design system, ensuring brand consistency.
• Design-Time/Runtime Dual Mode: Real-time adjustment of animation parameters in Play Mode with automatic rollback on exit; persistent saves when not in Play Mode.
• Version Control Friendly: The Library is a Unity Asset with readable Git diffs, enabling conflict-free team collaboration.

Configuration-Driven Architecture Chart configurations are Unity assets, reusable across scenes via drag-and-drop.
All styling is configured in the Inspector, with no hardcoding in scripts.
Runtime JSON data injection fully decouples business logic from the presentation layer.

✨ Pro Professional Features

🎨 Advanced Visual Effects

• Texture Fill System: Gradient, noise, and pattern fills to create unique visual styles.
• Texture Animation System: Multi-layer texture animation overlay for rich dynamic effects.
• Background Animation Support: Multi-layer background texture animations, supporting shortcuts like single/batch cloning and copy-paste editing.
• Advanced Styling: Shadows, glows, and rounded corners for refined visual adjustments.

📊 Extended Chart Types

• Basic Charts: Line, Bar, Scatter, Pie, Radar.
• Advanced Charts: Heatmap, Candlestick, Gauge, Funnel, Ring.
• 3D Series: Pie3D, Line3D, Bar3D, Scatter3D (supporting auto-rotation and interactive controls).

🎬 Animation System

• Smooth entry/exit transition animations.
• Data update animations.
• Interactive animation feedback.

🚀 Performance Optimizations

• Vector rendering (crisp and clear at any resolution).
• Automatic Draw Call batching.
• Core rendering path with zero per-frame GC allocations.
• 3D rendering optimization (smart RenderTexture refreshing).

🛠️ Enterprise-Grade Support

• Priority technical support.
• Faster update frequency.
• Customization within a limited scope (aligned with plugin development direction).

💡 Why Choose EasyChart Pro?

Pain Points of Traditional Solutions:

• Hand-writing Mesh → tweaking vertices → hardcoding styles → rewriting for a different UI system.
• Designers rely on developers to implement effects, resulting in high communication costs.
• Charts for different platforms require duplicate configuration, making maintenance difficult.

EasyChart Pro Advantages: Drop Asset → Library Visual Editing (Texture, Animation, 3D) → One-Click Sync → Done.

Designers independently produce professional-grade results, developers focus on business logic, and project delivery efficiency is improved by 10x.

Package contains 91 VFX prefabs for attack and impact:

- 66 attack VFX (33 on ground + 33 on air)

- 25 impact VFX

- 1 custom particle system driven shader

- Demo scene to preview all VFXs.

Made in URP, requires depth texture

Package contains a variety of attack VFX including slash, heavy and claw attacks with their respective impact VFXs. Attack VFXs comes with an air and ground version.

Assets can be used for of genre including Action, MMOs or sRPGs.

👉🏻💗Set of touch/mouse click VFX for any genre of games.💗👈🏻

Package includes demo scene with on click behaviour for preview.

Usable for a multitude of genres of games.

Note : Scripts are not necessarily game-ready and are strictly for demo purposes.

Archive Extractor for Unity

Extract archives directly inside the Unity Editor from the Project window.

Archive Extractor is a lightweight editor extension that adds a context menu action for archive files in the Unity Project window and extracts them into a folder next to the selected archive.

It is designed for teams and solo developers who regularly import external content packs, source files, or archived assets into Unity projects and want a simple in-editor workflow.

Features

- Extract archives directly from the Unity Project window

- Creates an output folder next to the archive using the archive file name

- Simple editor workflow with no external executable requirements

- Supports common archive formats through managed .NET libraries

- Works inside the Unity Editor without command-line tools

Supported Formats

- .zip

- .rar

- .7z

- .tar

- .tar.gz

How It Works

1. Select an archive file in the Unity Project window

2. Right-click the file

3. Choose the extract action from the context menu

4. The archive is extracted into a folder with the same name as the archive, next to the original file

5. Unity refreshes the AssetDatabase automatically

Example

If you have:

`Assets/Imported/my_pack.rar`

The extracted files will be placed in:

`Assets/Imported/my_pack/`

Use Cases

- Importing downloaded asset packs into Unity projects

- Unpacking source archives from artists or collaborators

- Reviewing archived content without leaving the Unity Editor

- Speeding up pipeline and content setup workflows

Requirements

- Unity 2021.3 or newer recommended

- Editor-only tool

- No runtime component

- No external command-line archive tools required

All tracks delivered as WAV 44,100 Hz 16-bit, mastered to -18 LUFS and -1 dBTP true peak. Game-engine ready for Unity, Godot, and GameMaker with no volume adjustment needed. All loops are click-free and tested.

Your game looks right. The atmosphere is there. Then you hit play and hear silence, or something generic that kills everything you built.  

Indie Horror Music Essentials Vol.1 is a complete audio toolkit for a horror game, start to finish. Every scenario covered in one pack.   

WHAT IS INSIDE  

16 tracks covering everything your game needs:  

• Exploration (3 looped tracks): Indoor spaces, outdoor desolation, underground claustrophobia. Each loops cleanly with no audible seam.  
• Tension and Chase (4 looped tracks): Low tension, high tension, moderate chase, and intense chase. Escalation from unease to full panic.  
• Stingers (5 one-shot tracks): Soft dread, medium shock, loud impact, slow reveal, and silence break. A tool for every kind of scare.  
• Scenes (3 looped tracks): Safe room, title screen, and the contrast moments that make the scary parts land harder. 
• One-shot cues (2 tracks): Discovery and death screen. Stems included for all 3 exploration tracks, so you can build adaptive audio that reacts to your gameplay.

LICENSE  

Use in any commercial project including Steam, console, and Itch.io releases. Full monetization on YouTube and Twitch with no copyright claims. No attribution required. Cannot be resold as audio assets or used for AI training.   

A freelance composer charges $800 to $2,000 to score a horror game. This pack covers your entire game for a fraction of that, with a clean license and no surprises.

A light, fun and flexible set of low-poly game assets that are ideal for prototyping or as an addition to a low-poly world. Includes a modular mounting system and many parts that allow you to create an underground metro with all possible branches.

This package works well for third-person or top-down viewing.

In addition to all this, the asset includes any parts that may be needed to develop a survival game.

The entire package is created in a polygonal style with the ability to be combined with other polygonal style packages.

More than 500 models for game development.

◼ Models info ◼

Buildings (x4)

Exteriors (x68)

Interiors (x37)

Items (x52)

Platform (x13)

Walls Floors (x36)

Door&Windows (x35)

Inner Walls Floors (x11)

Steps (x14)

Props (x51)

Train Modular (x20)

Tunnels (x41)

Addons (x67)

Pipes (x44)

Wires (x20)

◼ Asset info ◼

Models variation: 513

Max poly count: 15000

Min poly count: 20

Textures count: 1

Textures size: 1024x1024 px

◼ Compatibility ◼

- Support Universal Render Pipeline (URP)

- Support High Definition Render Pipeline (HDRP)

Follow us for updates and news

Email | Facebook | Discord | News

Audio file types: wav

Sample rate: 44100

Bit depth: 24bit

Loopable: Yes

Additional: Stereo

Free JRPG Game Music Pack

This Pack Contains:

• 12 Stylized JRPG Tracks + Loops

Tracklist:

1. Immortal Dream
2. Echoes of The Past
3. Whispers Beyond (+Looped version)
4. Echoed Blades (+Looped version)
5. Starfall Dreams (+Looped version)
6. Divine Echo (+Looped version)
7. Eternal Mists (+Looped version)
8. Azure Memories (+Looped version)
9. Frostfire Tales (+Looped version)
10. Moonlit Journey (+Looped version)
11. Celestial Path (+Looped version)

12. Harmony Blades (+Looped version)

Inspired by "Expedition 33" Soundtrack.

All tracks are original and human made, No AI was used in the creation process.

License Info

Free for commercial use.

You won't face any problems with your game's Youtube videos.

If you have some questions, contact me at alkakrab04@gmail.com

Texture dimensions:1024X1024

Number of textures: 26

Rigging:Yes

♦Characters (x28)♦

pack01:Character_Skeleton Soldier,Character_Skeleton_Archer,Character_Skeleton_Warrior,

Character_Skeleton_Mage,Character_Skeleton_Lord,Character_Zombie,

Character_Giant Zombie,Character_Ghost_Thug,Character_Ghost_Wailing Banshee

pack02:Werewolf,FemaleWerewolf,UndeadSamurai,GhostNinja,mummy,Mummy_Pharaoh,Vampire,Vampire_2,Chinese Zombie

pack03:Wraith,Lich,DeathKnight,Demon,Oni,Tengu,Anubis,Frankenstein,HeadlessHorseman,Undead Horse

(Multiple replacement colors)

♦Weapons(28)♦

pack01:Weapon_Arrow,Weapon_Broken buckler,Weapon_Broken Knife,Weapon_Broken one-handed ax,Weapon_Broken Scepter,Weapon_Staff,Weapon_Tower Shield,Weapon_Wood Bow,Weapon_Wooden Stick

pack02:Weapon_GoldenScepter,Weapon_PharaohSword,Weapon_Spear,Weapon_Kunai,

Weapon_Ninja Scabbard,Weapon_Ninja Sword,Weapon_Samurai Sword,Weapon_Samurai Sword2,Weapon_SamuraiSword3,Weapon_Scabbard,Weapon_Scabbard2,

Weapon_Scabbard3

pack03:Weapon_Ax,Weapon_Great Sword,Weapon_Shield,Weapon_knife,Weapon_knife02,

Weapon_Mace,Weapon_Stick

The texture size is (1024 x 1024) and the file format is PNG,It is using 1 diffuse texture map.Material is using Unity's URP/Lit shader.

Polycount:

Characters:

pack01:

Character_Skeleton Soldier：4962 triangles

Character_Skeleton_Archer：6162 triangles

Character_Skeleton_Warrior：6520 triangles

Character_Skeleton_Mage：6511 triangles

Character_Skeleton_Lord：6958 triangles

Character_Zombie：4849 triangles

Character_Giant Zombie：4856 triangles

Character_Ghost_Thug：4098 triangles

Character_Ghost_Wailing Banshee：5018 triangles

pack02:

Werewolf：4634 triangles

Female Werewolf：5751 triangles

Undead Samurai：8557 triangles

Ghost Ninja：4654 triangles

mummy：5929 triangles

Mummy_Pharaoh：7512 triangles

Vampire：4298 triangles

Vampire_2：4549 triangles

Chinese Zombie：4042 triangles

pack03:

Wraith：5846 triangles

Lich: 6895 triangles

Death Knight: 8296 triangles

Demon: 6194 triangles

Oni: 5532 triangles

Tengu: 7530 triangles

Anubis: 5222 triangles

Frankenstein: 9168 triangles

Headless Horseman: 4806 triangles

Undead Horse: 3454 triangles

Weapons:

pack01:

Weapon_Arrow：102 triangles

Weapon_Broken buckler：130 triangles

Weapon_Broken Knife：136 triangles

Weapon_Broken one-handed ax：178 triangles

Weapon_Broken Scepter：530 triangles

Weapon_Staff：248 triangles

Weapon_Tower Shield：424 triangles

Weapon_Wood Bow：420 triangles

Weapon_Wooden Stick: 132 triangles

pack02:

Weapon_Golden Scepter：704 triangles

Weapon_Pharaoh Sword：402 triangles

Weapon_Spear：327 triangles

Weapon_Kunai：172 triangles

Weapon_Ninja Scabbard：78 triangles

Weapon_Ninja Sword：294 triangles

Weapon_Samurai Sword：328 triangles

Weapon_Samurai Sword2：328 triangles

Weapon_Samurai Sword3: 328 triangles

Weapon_Scabbard：158 triangles

Weapon_Scabbard2：158 triangles

Weapon_Scabbard3：158 triangles

pack03:

Weapon_Great Sword：524 triangles

Weapon_Shield: 358 triangles

Weapon_Mace: 526 triangles

Weapon_Stick: 740 triangles

Weapon_Ax: 218 triangles

Weapon_knife: 150 triangles

Weapon_knife02: 74 triangles

Rigging:Yes

Animation Type : Humanoid(Undead Horse: Generic)

Texture dimensions:1024X1024

Number of textures: 1

Rigging:Yes

♦Characters (x1)♦

 Halfling Thief

The texture size is (1024 x 1024) and the file format is PNG,It is using 1 diffuse texture map.Material is using Unity's URP/Lit shader.

Polycount:

Characters:

Halfling Thief: 5178 triangles

Rigging:Yes

Animation Type : Humanoid(Undead Horse: Generic)

Based on Unity GUI
Provide 2 examples
Include source code
Include explanatory documents

This package can help you convert TTF font text to texture2d.
So that you can draw text directly on the surface of the 3D model or apply it to other places where you need to convert text to Texture2D!
This package not use BMFont or other tools.
The package include full source code and guide document!

Based on Unity GUI
An animation effect where text falls down
Support multiple languages
Provide 4 examples
Provide source code and documentation

This UI is Unity GUI(UGUI) component!
This UI simulate the falling text in the movies of the matrix!
Component support multiple languages
Component include source code and instructions document!

This effect utilizes Low-level graphics library - GL
Supported Development Platforms:
Windows: Yes
Mac: Yes
Provide examples
Include source code
Include explanatory documents
Supported Unity Pipelines:
Built-In Renderer
Universal Render Pipeline
High Definition Render Pipeline

This effect will make the lines you draw full of vitality.Lines will fly around
The effect looks very interesting
Component include source code and instructions document!

Note: This effect utilizes Low-level graphics library - GL (the graphic will always be displayed on the top layer of the camera)