Asset Store newest packages

Terrain Generation

Infinite terrain generation driven by configurable noise functions (frequency, amplitude, octaves, fractal behavior, domain warp, etc.).

Terrain mesh LOD support to scale geometric complexity with distance.

Object Placement

Rule-based procedural spawning per biome with deterministic controls.

Spawn constraints include probability, density, min/max spacing, per-tile limits, slope/height filtering, and exclusion logic.

Object Rendering

High-density vegetation rendering using instancing/batched workflows to minimize draw calls.

Configurable render distance and density budgets to target multiple hardware tiers.

Biome Authoring

Multi-biome architecture based on ScriptableObject configurations.

Per-biome control over terrain shaping, surface appearance, vegetation sets, and spawn rules.

Pathfinding & Navigation

Built-in A* pathfinding pipeline with automatically generated navigation grids.

Asynchronous path computation to avoid main-thread stalls.

Structure Placement

Prefab-based procedural structure spawning with terrain-aware adaptation.

Supports hollow and carve placement modes depending on structure-ground interaction needs.

Performance Characteristics

Chunk pooling and object reuse reduce GC pressure and memory spikes.

Burst + Jobs accelerate critical runtime systems (especially visibility/culling workflows).

LOD + distance-based policies provide scalable performance in large open worlds.

Independent quality knobs for terrain, vegetation, object draw distance, and spawn density.

Compatibility

Unity 2021.3 LTS or newer.

Includes FastNoiseLite dependency (Burst-compatible workflow).

Compatible with all Unity-supported target platforms.

Also tested and functional on version 2022.3.62f2 of the editor.

LIVE DEMO available here

TerrainGen is a powerful, deterministic procedural terrain generation system for Unity, allowing developers to create infinite, fully customizable worlds with multiple biomes, dynamic vegetation, modular structures, and integrated navigation and pathfinding systems.

The system generates infinite terrain using noise-based algorithms. Terrain loads dynamically around the player or camera position at runtime. Multiple biomes can be created, each supporting custom materials, height multipliers, and surface levels. The terrain is generated automatically with full collision support.

Rivers can be generated with configurable depth, width, and erosion parameters.

Vegetation and objects spawn intelligently based on biome-specific rules. The system supports trees, grass, general objects and far object with different render distances. Spawn probabilities, distances, object limits, and more are fully configurable.

Grass and far object rendering uses Unity's Graphics.DrawMeshInstanced and Frustum culling for high performance. Grass density, height constraints, and surface angle limits are all configurable.

Structures can be placed as prefabs with automatic terrain adaptation. Structures can carve terrain in hollow mode or anchor to terrain height. Spawn rules include spacing, biome restrictions, and unique instance options.

A built-in A* pathfinding system works across the generated terrain. Navigation grids are generated automatically per terrain tile. Walkable surface angles and height constraints are configurable.

Editor tools include a scene creator for quick setup, a terrain preview window for visualization, automatic tag setup, and biome visualization gizmos.

The system is highly customizable and suitable for open-world games, survival games, RPGs, simulation games, and sandbox games. All components are modular and configured through ScriptableObjects and Inspector settings.

Comprehensive documentation with examples is included, along with a demo scene for quick start build in URP.

Important Notes:

This asset includes a set of demo graphical assets (models, textures, materials, and prefabs) created for this asset. No third‑party visual assets are included; details and inventory are provided in the ASSETS_LICENSE_INFO.md file inside the package.

The terrain generation system uses a third‑party noise library (FastNoiseLiteBurstCompatibleForUnity), which is distributed under the MIT license. License information and credits are documented in the included THIRD_PARTY_NOTICES.txt file.

For support or inquiries, please contact me at guillaume.marrec.frey@proton.me. I am happy to help with any problems or concerns.

• CEF off-screen rendering: Chromium/CEF renders web content off-screen into textures consumable by Unity.
• Native plugin (C++) + C# bridge: Native rendering, encoding and browser control exposed to Unity via P/Invoke and managed wrappers.
• Graphics API integration: Integration with Direct3D11, Direct3D12 and Vulkan for shared-texture zero-copy, hardware composition, or upload paths.
• Video hardware decoding: Support for H.264 / H.265 / AV1 hardware-accelerated decode pipelines.
• WebRTC: Chromium WebRTC stack for real-time audio/video and cloud rendering access.
• External BeginFrame & message-loop coordination: Unity-driven frame cadence coordinating CEF message-loop pumping and external begin-frame signaling.
• Input/IME forwarding and event bridge: Unified handling of mouse/keyboard/drag/scroll/IME events mapped to browser/web events.
• Software fallback path: Software rendering plus CPU→GPU upload for environments lacking GPU shared paths.

• High-performance pipeline: GPU-first composition (D3D11/D3D12/Vulkan) with zero-copy or hardware composition to minimize CPU and main-thread load.
• Multi-backend compatibility: Works with Direct3D11, Direct3D12 and Vulkan to cover modern GPUs and rendering pipelines.
• Rich video codec support: Native hardware-accelerated H.264, H.265 (HEVC) and AV1 decoding for high-resolution streaming (e.g., 8K@60fps).
• Major site compatibility: Plays and interacts with mainstream video sites (YouTube, bilibili) and standard H5/HTTPS/CSS/JS content.
• WebRTC & cloud rendering: Supports WebRTC for cloud-rendered frames and real-time audio/video communications.
• Full browser capabilities: Page navigation, script execution, Chrome DevTools debugging, mouse drag, and Ctrl+wheel zoom supported.
• Bidirectional Unity ↔ JavaScript integration: Structured event bridge and raw messaging channels for clean integration between game logic and web UI.
• Transparent-background mouse-through: Transparent pages can forward mouse events through transparent pixels with an adjustable alpha threshold.
• IME and input support: Proper IME handling, cursor sync and localization-aware input.
• GPU binding & isolation: GPU-binding strategy separates Unity and browser workloads to reduce interference and improve throughput.
• High-framerate capable: Designed to achieve stable high framerates (including 120fps where hardware and configuration permit) with minimized dropped frames.
• Software fallback & compatibility: Software rendering + CPU→GPU upload fallback when GPU shared paths are unavailable.
• Tunable and diagnosable: Configurable target/idle frame rates, input/paint boosts, and performance overlay for profiling and tuning.

window trial demo

THIRD-PARTY ASSETS

• Asset uses Chromium Embedded Framework (CEF) under BSD 3-Clause License; see Third-Party Chromium Embedded Framework_License.txt file in package for details.
• Asset uses SwiftShader under Apache License 2.0; see Third-Party SwiftShader_License.txt file in package for details.
• Asset uses Vulkan API Loader under MIT License; see Third-Party Vulkan_License.txt file in package for details.
• Asset uses DirectXShaderCompiler (DXC) under University of Illinois Open Source License (NCSA / MIT-style); see Third-Party DirectXShaderCompiler_License.txt file in package for details.

• Policy-based release readiness scoring system

• Blocking rules with category and severity filtering

• Indie Mode and Studio Mode workflows

• Per-checker policy overrides

• Auto-fix support for selected build issues

• CI-ready reporting (Markdown and JSON export)

• Build settings and platform validation

• Define symbol checks and suspicious define detection

• Project configuration validation

• Graphics API and rendering configuration checks

• Icon and splash screen validation

• Missing reference detection

• Default balanced policy profile included

• Works with Built-in, URP and HDRP

• Editor-only tool (no runtime impact)

• Compatible with Unity 2021.3 LTS and newer

Build Guard Pro helps game developers maintain high-quality builds by detecting configuration issues, policy violations, and release blockers before shipping.

Designed for both indie developers and studios, it provides a structured audit workflow with scoring, blocking rules, and optional auto-fix capabilities.

Instead of manually checking build settings, project configuration, scripting defines, icons, splash screens, or platform settings, Build Guard Pro performs a structured audit and provides a clear release readiness score.

Whether you are preparing for store submission, client delivery, or automated CI builds, Build Guard Pro ensures your project meets your defined quality standards.

• Model Type: Low-poly auto rickshaw
• Mesh Count: 1 model
• Prefab Count: 5 models
• Vertices Count: 6,948
• Color Variations: 5 different color variants (single model with multiple textures/materials)
• Polygon Count: Optimized for real-time performance (low poly)
• Texture Size: 1K textures
• Texture Types: Albedo (Base Color), Metallic, Roughness, Normal, Emissive.
• Total Texture: 39
• Texture format: PNG
• Materials: Standard PBR material
• UV Mapping: Yes (non-overlapping)
• Rigged: No
• Animations: None
• File Format: FBX
• Pivot Point: Correctly placed for easy positioning and movement
• Scale: Real-world scale
• Render Pipeline: Built-in
• Platforms: PC, Mobile, VR
• Use Cases: Games, VR experiences, simulations, racing games, environment props

This package features a low-poly auto rickshaw 3D model optimized for real-time use in Unity games, VR applications, simulations, and racing environments. The asset includes five color variations using a single optimized model, ensuring excellent performance with minimal draw calls.

Designed for flexibility, the auto rickshaw can be used as a playable vehicle, AI traffic car, or environment prop in city, street, and urban game scenes. Its lightweight low-poly geometry makes it suitable for mobile, PC, and VR platforms.

All materials are fully customizable, allowing developers to easily change colors, apply custom shaders, or adapt the asset to different art styles. This model integrates seamlessly into driving games, simulation projects, VR experiences, and stylized environments.

Ideal for indie developers and studios looking for a performance-friendly vehicle asset, this low-poly auto rickshaw adds realism and regional character to any interactive project.

Unity Compatibility

• Unity 2021 LTS
• Unity 2022 LTS
• Unity 2023 LTS
• Unity 6

Editor-only tool (does not affect runtime builds).

Validation Scope

RefSafe Pro supports:

• Active scene scanning
• Multi-scene scanning
• Build Settings scene scanning
• Project-wide scene scanning
• Prefab asset scanning
• ScriptableObject asset scanning

Unloaded assets are processed safely via editor asset enumeration.

Detection Coverage

RefSafe Pro detects:

• Missing MonoBehaviour scripts on GameObjects
• Missing serialized object references in components
• Broken asset bindings
• Null references stored in serialized fields

Each issue includes:

• Asset path
• Scene or prefab name
• GameObject reference
• Component type
• Severity classification

Performance & Control

• Non-blocking progress bar UI
• Cancellation support for long scans
• Scan duration metrics
• Optimized traversal for large projects

Reporting & Export

Supported export formats:

• CSV
• JSON
• HTML
• TXT

Reports include structured issue metadata suitable for:

• Team review
• QA validation
• Build verification workflows
• CI documentation

Architecture Notes

• Editor-only assembly
• Does not modify assets automatically
• Manual resolution workflow (no destructive changes)
• Safe for version-controlled projects

RefSafe Pro – Project-Wide Missing Reference Validator for Unity

RefSafe Pro is a production-ready Unity Editor validation tool designed to detect missing scripts and broken serialized references across your entire project.

Unity projects grow. Prefabs change. Scripts get renamed. References disappear silently. The problems often surface only at runtime—or worse, after shipping.

RefSafe Pro helps you identify these issues early.

What RefSafe Pro Does

RefSafe Pro scans:

• Open scenes
• All scenes in Build Settings
• Entire project scenes
• Prefabs
• ScriptableObjects

It detects:

• Missing MonoBehaviour scripts
• Broken serialized object references
• Null bindings that can cause runtime exceptions

All results are structured, categorized, and easy to navigate.

Built for Production Workflows

RefSafe Pro is designed for developers and studios who need deterministic validation before builds.

Key capabilities include:

• Project-wide scanning
• Scene validation without manually opening scenes
• Prefab and ScriptableObject validation
• Progress bar with Cancel support
• Scan duration metrics
• Severity classification (Critical / Warning / Info)
• Advanced result filtering
• Export reports (CSV, JSON, HTML, TXT)

Whether you're preparing a release build or maintaining a large project, RefSafe Pro ensures reference integrity across your assets.

Part of the RefSafe Ecosystem

RefSafe is structured as a two-tier validation system:

• RefSafe Lite — Free scene-level reference validation
• RefSafe Pro — Full project-wide validation for production pipelines

Start with scene validation. Scale to full project coverage when needed.

Why Use RefSafe Pro?

• Prevent runtime errors caused by broken references
• Avoid manual hierarchy searching
• Validate entire projects before shipping
• Maintain reference integrity in large Unity productions
• Generate structured reports for team review

RefSafe Pro does one thing clearly and reliably:
It finds broken references across your Unity project.

Car Paint Shader Ultimate is a complex, but easy to use vehicle Shader Graph for easy customisation.

Features:

• Main color or image texture
• Second color with configurable power and spread
• Normal map
• Clearcoat
• Metallic flakes with fresnel
• Procedural orange peel effect
• Scratches affecting smoothness and normal
• Animated rain drops affecting smoothness and normal
• Configurable dirt with triplanar projection - can be set up for any object, with variable amount or height, could be also used as snow accumulating from the top. Dirt also contains configurable bump and smoothness - can be either light layer of sand, or thick wet mud.

Vehicle models used in screenshots by Lionsharp Studios & Martin Trafas licensed under Creative Commons Attribution, not included in the package.

SFX: 103

File Type: WAV

File Format: 44100 Hz/16 Bit

Snow Sound Effects is a high-quality audio pack featuring over 100 ready to use snow-themed sound effects, designed specifically for game developers and filmmakers looking to bring winter environments to life. This collection captures the crisp, immersive details of snowy interactions, including snowball whips, snowball throws, ice pebbles dropping, and satisfying snow crunches underfoot. Each sound is carefully crafted and optimized for seamless integration into your projects, helping you create realistic and engaging cold-weather scenes.

Whether you're building a snowy game level, enhancing cinematic winter landscapes, or adding tactile realism to your audio design, this pack delivers versatile and professional-grade sounds. From shoveling snow to throwing it and everything in between, Snow Sound Effects provides the essential elements needed to elevate your production with authentic winter audio. Perfect for indie developers, AAA studios, and filmmakers alike, this collection ensures your scenes sound as cold and dynamic as they look.

Preview HERE

Audio File List

SFX: 200

File Type: WAV

File Format: 44100 Hz/16 Bit

Alien Sound Effects is a professionally crafted audio pack featuring 200 ready to use alien voice sound effects designed for game developers, filmmakers, and content creators seeking unique extraterrestrial audio. This collection delivers a wide range of expressive and otherworldly vocalizations, perfect for bringing alien characters, creatures, and sci fi environments to life. Whether you are working on a space themed game, cinematic project, or immersive storytelling experience, these high quality alien sounds provide the versatility and clarity needed for seamless integration into any production.

This pack includes 10 distinct alien voices, each with 20 carefully designed sound effects covering a variety of moods and actions such as communication, aggression, curiosity, and ambient vocal textures. Every sound is optimized for immediate use, helping streamline your workflow while maintaining professional audio standards. Alien Sound Effects is an essential resource for adding depth, personality, and authenticity to your sci fi projects, making it easier than ever to create engaging and memorable audio experiences.

Preview HERE

Audio File List

- Number of characters: 1

- Mesh variations:

  Includes 2 UV setups:

  • UDIM workflow (adapted for Unity via custom shader)

  • Single UV (Mono)

- Number of meshes:

  1 character mesh

- Polygon count:

  Character: ~130,000 tris

- Texture resolutions:

  2K

- Texture maps included:

  Base Color, Normal, ORM (AO, Roughness, Metallic), Alpha

- Number of materials:

  8 total:

  • Body (clean/dirty – UDIM & Mono)

  • Cloth (clean/dirty)

  • Eyes

  • Lacrimal

- Number of shaders:

  4 (ORM, ORMA, Lacrimal, UDIM)

- Rigged:

  Yes

- Animation:

  No

- UV mapping:

  Yes (UDIM + standard 0–1 UV layout)

- LODs:

  No

- Supported Render Pipeline:

  Universal Render Pipeline (URP)

- Shader type:

  Custom Shader Graph

- Additional features:

  • Alpha clipping support for damaged clothing

  • Fresnel-based lacrimal eye shader for realistic wetness

  • Packed ORM texture workflow

  • Multiple material variations (clean/dirty)

This package includes a high-quality game-ready 3D character designed for real-time applications in Unity URP.

The asset features a fully rigged character with clean topology, optimized UVs, and a flexible material system built using Shader Graph. The included shaders support a standard PBR workflow, cutout materials for damaged clothing, and a specialized lacrimal shader for realistic eye wetness.

The character is suitable for a wide range of projects including stylized and semi-realistic games, cinematics, and real-time applications.

A demo scene is included to showcase the materials and setup.

Shaders included:

- ORM Shader: Standard PBR workflow using packed textures (AO, Roughness, Metallic)

- ORMA Shader: Extended version with alpha clipping for cutout details

- Lacrimal Shader: Transparent shader with Fresnel effect for eye realism

- UDIM Shader

All materials are customizable and exposed in the inspector for easy integration into your project.

• 2 textures
• 52x64 texture size
• Average polygon count per weapon is 2800
• Minimum gun size is 1378
• Maximum gun size is 5097
• Gun meshes 92, Melee meshes 5, Utility meshes 14
• No rigging included
• No animations included
• UV mapped
• No LODs included
• Albedo and metallic map included

Old Low-poly Weapons Pack that contains:

• 11 Guns with individual ammo

- SMG + Drum mag + Grip

- Sniper rifle + Scope

- LMG + Bipod

- Shotgun

- Semi-auto rifle

- Cheap SMG + 2 silencers

- Double barrel

- Pistol

- Heavy pistol

- Revolver

- Old pistol

• 5 Melee weapons

- Knife

- Machete

- Knuckle

- Sledgehammer

- Bat

• 4 Utility items

- Handgrenade

- Incendiary grenade

- Cocktail + Lighter

- Landmine

mobile, beast, alien, doom, creature, monster, human, humanoid, people, medieval, fantasy character, game, low poly, pbr, rigged, animation, unity, unreal, rpg

Number of unique asset: 1

Average polygon count: 6816

Texture dimensions: Body 2k

Texture map: PBR

faces 6880

verts 6816

tris 13476

Fully animated

Model contains 28 animations including attack (x8), walking (x3), running (x1), turn (x1), react (x4), idle (x1), death (x3), jump (x3), dancing (x2)

Transform your game!

Purchase your premium 3D character now!

• Unity Version: 2022.3 LTS
• Render Pipeline:Built-in (base setup)
  URP (included)
  HDRP (included)
  
• Textures: PBR (Albedo, Normal, Metallic, Roughness)
• Texture Resolution: 2K
• File Format: FBX + Unity Package
• Scale: Real-world scale (meters)
• Prefabs: Yes (fully set up)
• Scenes Included: 4 complete demo scenes

The HQ Hospital Pack is a high-quality, fully detailed 3D medical environment designed to create realistic hospital scenes for modern applications.

This pack includes 4 complete hospital environments, each crafted with realistic assets, clean topology, and optimized performance. It is ideal for games, VR/AR medical simulations, training applications, and architectural visualization.

Each environment includes dedicated URP and HDRP packages, ensuring smooth compatibility across Unity render pipelines.

 Included Environments

• Hospital Hallway
• Hospital Room
• Hospital Ward Room
• Operation Theatre (OT Room)

Key Features

• 4 complete hospital environments
• URP + HDRP support included
• High-quality realistic assets
• Modular and easy to customize
• Optimized for real-time performance
• PBR materials and textures
• Clean hierarchy and organized structure
• Ready-to-use prefabs and scenes

About the Creator – Artisan 3D Ventures

Artisan 3D Ventures is a team of experienced 3D artists with over a decade of expertise in creating high-quality, game-ready assets.

Explore more assets by visiting the Artisan 3D Ventures publisher profile.

Support & Feedback

If you like this asset, please consider rating and reviewing — your support helps us grow!

For support or inquiries:
artisan3dventures@gmail.com

• 17 High-quality WAV files
• 4 Original Music (Full Mix)
• 4 No Beat Versions (Texture focus / soft mix)
• 1 Bonus Short Loop (21s)
• 7 Essential SFX Pack included

• All Music and No Beat Version tracks loopable
• 44.1kHz / 16 bit / Uncompressed Wav
• Each music track includes BPM in the filename for easy synchronization

Emotional Journey is a high-quality audio collection designed to evoke deep nostalgia and peace.This pack is a complete audio solution for developers creating story-driven narratives, healing games, or relaxing atmosphere-focused on projects.

It features 4 unique musical themes with their No Beat Version(soft mix), providing seamless transitions between emotional storytelling and background environments. To ensure immediate integration, I've included 7 essential gameplay SFX that perfectly match the pack's emotional tone.

This Asset includes:

-A car model (of .dae type)

-A prefab for the car (1970sMuscleCar#11.prefab)

-All the textures for the car (24)

-All the materials for the car (20)

-A demo scene for visual showcasing

Asset Features:

-UV unwrapped body with backup texture

-Low poly generic 70s interior

-Detailed undercarriage

-Functional Doors

-Separate Steering Wheel

-Ambient Occlusion baked texture for body

Separate body parts:

-Doors

-Wheels

-Steering Wheel

All Texture Details:

8x8: 

-shadow_TEXTURE.png

1024x512:

-numberplate_TEXTURE.png, numberplate_NRM.png

512x1024:

-undercarriagelod_NRM.png, undercarriagelod_TEXTURE.png

1024x1024:

-interior_TEXTURE.png, interior_NRM.png, interior_METAL.png, grill_TEXTURE.png, grill_NRM.png, trimmings_NRM.png, holes_TEXTURE.png, squarelight_TEXTURE.png, squarelight_NRM.png, headlight_TEXTURE.png, headlight_NRM.png, tyre_NRM.png, tyre_TEXTURE.png, undercarriage_TEXTURE.png, undercarriage_NRM.png, underchrome_TEXTURE.png, underchrome_NRM.png, windows_TEXTURE.png

4096x4096:

-bodymap_TEXTURE.png x 2

All Texture Types:

-Albedo

-Metallic/Specular

-Normal

All LOD Mesh Details: Prefab has 4 LOD States

-LOD_1 (Detail): 41,767 tris

-LOD_2: 36,181 tris

-LOD_3: 14,781 tris

-LOD_4: 9,524 tris

Third-Party file license notices:

-Asset uses 1970sMuscleCar#11.dae, PrefabWorld.fbx; see 3D_Model_license_notice.txt file in package for details

-Asset uses bodymap_TEXTURE.png, interior_TEXTURE.png, interior_NRM.png, interior_METAL.png, grill_TEXTURE.png, grill_NRM.png, trimmings_NRM.png, holes_TEXTURE.png, squarelight_TEXTURE.png, squarelight_NRM.png, headlight_TEXTURE.png, headlight_NRM.png, tyre_NRM.png, tyre_TEXTURE.png, undercarriage_TEXTURE.png, undercarriage_NRM.png, underchrome_TEXTURE.png, underchrome_NRM.png, windows_TEXTURE.png, shadow_TEXTURE.png, numberplate_TEXTURE.png, numberplate_NRM.png, undercarriagelod_NRM.png, undercarriagelod_TEXTURE.png; see Textures_license_notice.txt file in package for details

• Resolution: 256x128 pixels (Optimized for performance and sharp UI).
• Color: Pure White (Base color optimized for real-time tinting).
• Format: High-Quality Transparent PNG.
• Quantity: 90+ Unique Button Shapes.
• Design: Clean, Vector-style aesthetic.
• 9-Slicing Ready: Perfectly calibrated for distortion-free scaling.
• Compatibility: Works seamlessly with Unity, Unreal Engine, Godot, and all major game engines.

Ultimate 90+ White UI Button Collection

This massive library of 90+ professional UI buttons is designed for maximum flexibility. Each button is provided in a clean, pure white format, allowing you to instantly change their color using your game engine's "Color/Tint" setting. One asset, infinite color possibilities.

Key Features:

• 90+ Unique Shapes: A vast variety of forms, from rounded and capsule styles to modern geometric and ornate shapes.
• Colorable & Tintable: Since every button is white, you can perfectly match your game’s theme in seconds without needing Photoshop.
• 9-Slicing Ready: All buttons are optimized for 9-slice sprite editing. Scale them to any width or height while keeping the borders crisp and undistorted.
• Clean Vector Style: High-resolution, sharp-edged designs that look great on everything from mobile screens to 4K monitors.

Why This Pack?

Stop creating separate assets for every color change. This collection provides the ultimate foundation for your UI system. Whether you need a bright green "Success" button or a deep red "Cancel" button, just pick a shape and set the color!

Core Simulation

• Configurable scan frequency
• Adjustable horizontal FOV
• Configurable vertical layers
• Max range configuration
• Per-beam angular resolution
• Layer mask filtering
• Noise model (Gaussian / configurable)
• Per-frame or fixed update execution

Backends

CPU Backend

• Physics.Raycast-based implementation
• Reliable and deterministic
• Suitable for small scenes and prototyping

GPU Backend

• Compute shader accelerated
• High beam count support
• Optimized for large-scale environments
• Suitable for real-time high-frequency sensors

Raytracing Backend (Optional / HDRP)

• Unity raytracing integration
• Physically accurate beam simulation
• Research-grade fidelity

Hybrid Backend

• Hardware-in-the-loop setups
• Gradual migration from simulation to real-world testing
• Sensor validation workflows
• Mixed-reality robotics environments

ROS Integration

• Publish LaserScan messages
• Configurable topic name
• Adjustable publish rate
• Supports ROS1 (via bridge)
• Designed for extension to ROS2

Occupancy Grid

• 2D grid generation
• Adjustable resolution
• World-aligned or sensor-aligned modes
• Real-time update
• Export support (optional)

Debug & Diagnostics

• Beam gizmo visualization
• Hit point visualization
• Range statistics display
• Performance monitor (scan time / frame cost)
• Backend selection UI
• Logging verbosity levels
• Mini Map
• Capture View 

Performance

Optimized for:

• Large scan counts
• Multi-layer LiDAR
• Autonomous driving simulations
• Multi-sensor setups

Lidar Component Pro extends the Basic package into a complete simulation and integration framework for advanced robotics and autonomous systems development.

Whether you're developing autonomous vehicles, SLAM pipelines, perception systems, or conducting academic research, Pro gives you the tools to simulate, visualize, debug, and export realistic LiDAR data efficiently.

🧠 Designed For

• Robotics developers
• Autonomous vehicle simulation
• Research & academic projects
• SLAM / mapping development
• ROS-based pipelines
• Simulation-heavy AI prototyping
• Hardware-in-the-loop setups

⚡ Key Advantages

🔥 High Performance GPU Backend

Accelerated LiDAR raycasting using GPU-based processing for large scan counts and high-frequency sensors.

🎯 Optional Raytracing Backend

High-fidelity simulation mode for realistic beam interactions and advanced research scenarios.

🛰 ROS Publisher Integration

Built-in ROS topic publishing support for seamless integration into robotics pipelines.

🗺 Live Occupancy Grid Generation

Generate 2D occupancy grids directly from scan data in real-time.

🔌 Hardware Integration Hooks

Interface-ready architecture for hybrid simulation + real sensor data.

🧰 Advanced Debugging & Visualization

• Beam visualization
• Noise model inspection
• Live scan statistics
• Backend switching at runtime
• Diagnostic logging modes

🏗 Modular Architecture

Pro is built around a backend-based architecture:

• CPU backend (baseline)
• GPU backend
• Raytracing backend
• Hybrid Backend (CPU+GPU)

You can switch backends or disable them depending on performance and simulation needs.

Core Features

• CPU-based LiDAR backend
  Raycast-driven point generation
  Deterministic and engine-agnostic behavior
• Configurable LiDAR parameters
  Range, horizontal/vertical FOV
  Scan frequency (Hz)
  Number of channels (rings)
  Points per scan
• Sensor-level filtering
  Layer-based hit and ignore masks
  Multi-layer exclusion support
• Ring filtering
  Ignore specific rings or ranges
  Useful for ground return suppression
• Real-time radar / minimap visualization
  Sensor-centered display
  Point fading and persistence
  Ring separation and styling

Architecture

• Modular backend system (ILidarBackend)
• Clean data contract (LidarFrame, LidarPoint)
• Decoupled visualization and processing
• Graceful fallback system for unavailable backends
• Designed for future Pro extensions

Backend Support (Basic)

• ✅ CPU Raycast Backend
• ⛔ GPU Backend (Pro)
• ⛔ Hybrid Backend (Pro)
• ⛔ Hardware Ray Tracing Backend (Pro)

Performance Notes

• Suitable for real-time use in small to medium scenes
• Performance scales with:
  Number of points per scan
  Scan frequency
  Scene complexity
• Layer filtering strongly recommended for optimal performance

Engine & Compatibility

• Unity (Built-in / URP compatible)
• Requires standard Unity Physics (colliders)
• No external dependencies
• No ROS required in Basic package

The LiDAR Component– Basic Package provides a real-time LiDAR sensor simulation built specifically for Unity. It enables developers to simulate realistic LiDAR scans using CPU-based raycasting, visualize sensor output through a radar-style minimap, and filter detections at the sensor level using layers and scan rings.

The system is designed with a clean, modular architecture that separates sensing, processing, and visualization. This allows the LiDAR data to be reused across different consumers such as HUDs, analytics tools, or future robotics integrations.

While the Basic package focuses on reliability and ease of use, the architecture is intentionally Pro-ready. Advanced features such as GPU backends, hardware ray tracing, occupancy grids, and ROS publishers are planned as optional Pro extensions without breaking the existing API.

This package is ideal for:

• Game developers needing sensor-based perception
• Simulation and AI prototyping
• Robotics concept demonstrations without ROS complexity
• Educational and research visualization

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

Join in to our LayerLab Discord Community!

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

ㅤ

A collection of high-quality 2D minimal enemy monster characters designed for casual games.

ㅤ

This pack includes 50 unique enemy characters with distinct designs and concepts, making it ideal for enemy units, wave systems, and stage compositions.

ㅤ

All characters are created with Unity animation and come with essential motion sets required for gameplay, allowing easy integration into your project. When used with the Minimal Series, it helps maintain a consistent visual style across your game.

ㅤ

👾 Contents

ㅤ

• 50 unique enemy characters
• Categories included : Snake, Beetle, Turtle, Wolf, Slime, Goat, Animal, Snail, Lizard, Buffalo, Bear, Goby, Blowfish, Crab, Jellyfish, Octopus, Bird
• Suitable for enemies, waves, and stage systems

ㅤ

🎬 Animations

ㅤ

• Idle
• Walk
• Attack
• Hit
• Dead

ㅤ

🎨 Features

ㅤ

• Minimal & casual art style
• High readability and clear silhouettes
• Built with Unity's animation system
• Ready-to-use prefabs included
• Fits seamlessly into various genres
• Consistent style with the Minimal Series

ㅤ

📦 Files Included

ㅤ

• Unity Package (.unitypackage)
• UAnimated character files (50 Characters x 5 Motion)

ㅤ

🎮 Recommended For

ㅤ

• Casual Games
• RPG
• Defense Games
• Action Games
• Mobile Games

ㅤ

🚫 This asset may not be used for training, input, or any purpose related to generative AI programs.

ㅤ

____________________

📦 MINIMAL SERIES

ㅤ

→ GUI Pro - Minimal Game Blue

→ GUI Pro - Minimal Game Light

→ GUI Pro - Minimal Game Dark

→ 2D Minimal - Character Maker

→ 2D Minimal - Icon Pack

→ 2D Minimal - Environment 1

→ 2D Minimal - Environment 2

→ 2D Minimal - Equip Item Pack

→ 2D Minimal - Artifact Icons

ㅤ

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

If there any suggest or idea for improvement feel free to contact me, if it

possible I will add your request in further updates.

ㅤ

📰 Follow us for updates and news!

Discord | X | Youtube | Facebook | Email

ㅤ

LAYERLAB

https://layerlab.games

Humanoid Rig Support: Yes

Animation: Yes (12 animation sample)

UV mapping: Yes

Polygon count:

vm_0034: ~16000 Tris:

4 Base Maps (1024 x 1024) (upper body, lower body, hair, foot)

4 Normal Map (1024 x 1024) (upper body, lower body, hair, foot)

vm_0035: ~23000 Tris -

3 Base Maps (1024 x 1024) (upper body, lower body, hair, foot)

3 Normal Map (1024 x 1024) (upper body, lower body, hair, foot)

vm_0036: ~21600 Tris

4 Base Maps (1024 x 1024) (upper body, lower body, hair, foot)

4 Normal Map (1024 x 1024) (upper body, lower body, hair, foot)

Custom Shader Graph for change skin color and eye color.

Lit and unLit Material.

Anime Male Pack

Standard Material:

-Diffuse Map, Normal Map.

Custom Shader Graph for change skin color, eye, outfit colors.

Create your own style with:

• Base skin colors: black, brown, yellow, base and you can change by TintColor in shader get more skin color.
• 5 Eye color: blue, cyan, pink, brown and yellow: and you can change eye Color with TintColor parameter of Shader.
• 3 Unique Outfits include: upbody; lowbody and foot.
• 3 Hairstyles

Model Support Humanoid.

vm_0031; vm_0032; vm_0033

Animation: 12

• M_IDLE (3)
• M_RUN
• M_WALK
• F_IDLE(3)
• F_RUN(2)
• F_WALK
• M_DANCE (1)

Animation with be update more in the next release.

Number of Shaders: 9

Shader Types:

- Flow

- Dual Flow

- Wave

- Wave Advanced

- Plane Wave

- Pulse

- Distortion

- Distortion Advanced

- Crack Glow

Number of Materials: 30

Number of Textures: 30

Texture Resolutions:

- 2048x2048 (30 textures)

- 1024x1024 (30 textures)

- 512x512 (30 textures)

Texture Type:

- Seamless / Tileable

Shader Pipeline:

- URP (Shader Graph)

Features:

- Unified Master Shader system

- Fully customizable parameters (emission, normals, smoothness, intensity)

- Animated effects controlled via shader properties

- Ready-to-use materials included

- Mobile-friendly performance

Supported Platforms:

- Android

- iOS

- Windows

- Mac

Notes:

- No particle systems included

- Designed for use with materials and meshes

- Easy to integrate into existing projects

Magic Energy Shaders Pack is a collection of stylized animated shaders designed to create dynamic energy effects for games and real-time applications.

This pack includes multiple shader types such as Flow, Dual Flow, Wave, Advanced Wave, Plane Wave, Pulse, Distortion, Advanced Distortion, and Crack Glow. Each shader is built on a unified master shader system, allowing flexible control over surface properties like emission, normals, smoothness and intensity.

The package also includes 30 seamless high-quality textures (2048, 1024, 512), organized into 6 thematic groups: Arcane, Fire, Water, Lightning, Poison and Energy.

All textures are provided as ready-to-use materials based on the master shader, making it easy to drag and drop them directly into your project.

This pack is suitable for:

- Magic effects

- Energy fields and shields

- UI highlights and backgrounds

- Stylized environments

- Mobile and PC projects

Shaders are optimized for performance and designed to be easy to customize via exposed parameters.

Perfect for developers looking to quickly add high-quality animated VFX to their projects.